# coding: utf-8

"""
    Verity471 Unified API

      - creds: 1.0.1
  - indicators: 1.0.0
  - malware: 1.0.0
  - reports: 1.0.0
  - sources: 1.0.2
  - actors: 1.0.1
  - watchers: 1.0.0
  - observables: 1.0.0
  - entities: 1.0.0
  - girs: 1.0.0


    The version of the OpenAPI document: 1.1.1
    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, StrictInt, StrictStr, field_validator
from typing import Optional
from typing_extensions import Annotated
from verity471.models.get_cred_occurrence_response import GetCredOccurrenceResponse
from verity471.models.get_cred_occurrence_response_stream import GetCredOccurrenceResponseStream
from verity471.models.get_cred_response import GetCredResponse
from verity471.models.get_cred_response_stream import GetCredResponseStream
from verity471.models.get_cred_set_accessed_url_response_stream import GetCredSetAccessedUrlResponseStream
from verity471.models.get_cred_set_response import GetCredSetResponse
from verity471.models.get_cred_set_response_stream import GetCredSetResponseStream

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


class CredentialsApi:
    """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 get_credential_sets_accessed_urls_stream(
        self,
        credential_set_id: Annotated[Optional[StrictStr], Field(description="Search by credential set id.")] = None,
        credential_set_name: Annotated[Optional[StrictStr], Field(description="Search by credential set name.")] = None,
        accessed_url: Optional[StrictStr] = None,
        girs: Annotated[Optional[StrictStr], Field(description="Filter results by custom GIRs (General Intelligence Requirements), my_girs or company_pirs. Using multiple values will return results based on the aggregated GIR list")] = None,
        victim: Optional[StrictStr] = None,
        var_from: Annotated[Optional[StrictInt], Field(description="UNIX timestamp(in milliseconds)")] = None,
        until: Annotated[Optional[StrictInt], Field(description="UNIX timestamp(in milliseconds)")] = None,
        last_updated_from: Annotated[Optional[StrictStr], Field(description="UNIX timestamp(in milliseconds) or period e.g. 24hours or 7days")] = None,
        last_updated_until: Annotated[Optional[StrictStr], Field(description="UNIX timestamp(in milliseconds) or period e.g. 24hours or 7days")] = None,
        size: Annotated[Optional[StrictInt], Field(description="Range is: [1, 1000]")] = None,
        cursor: Annotated[Optional[StrictStr], Field(description="Continue scrolling from cursor")] = 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,
    ) -> GetCredSetAccessedUrlResponseStream:
        """Credential set accessed url stream

        Returns list of Credential sets accessed urls matching filter criteria. The response contains “cursor_next” field, which should be provided to the next subsequent call to fetch potential next page of the results. Results are sorted by ascending order of the last_updated_ts field. Two indications of the end of the stream are possible: the result list is empty or its size is less than the requested items count.

        :param credential_set_id: Search by credential set id.
        :type credential_set_id: str
        :param credential_set_name: Search by credential set name.
        :type credential_set_name: str
        :param accessed_url:
        :type accessed_url: str
        :param girs: Filter results by custom GIRs (General Intelligence Requirements), my_girs or company_pirs. Using multiple values will return results based on the aggregated GIR list
        :type girs: str
        :param victim:
        :type victim: str
        :param var_from: UNIX timestamp(in milliseconds)
        :type var_from: int
        :param until: UNIX timestamp(in milliseconds)
        :type until: int
        :param last_updated_from: UNIX timestamp(in milliseconds) or period e.g. 24hours or 7days
        :type last_updated_from: str
        :param last_updated_until: UNIX timestamp(in milliseconds) or period e.g. 24hours or 7days
        :type last_updated_until: str
        :param size: Range is: [1, 1000]
        :type size: int
        :param cursor: Continue scrolling from cursor
        :type cursor: 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_credential_sets_accessed_urls_stream_serialize(
            credential_set_id=credential_set_id,
            credential_set_name=credential_set_name,
            accessed_url=accessed_url,
            girs=girs,
            victim=victim,
            var_from=var_from,
            until=until,
            last_updated_from=last_updated_from,
            last_updated_until=last_updated_until,
            size=size,
            cursor=cursor,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "GetCredSetAccessedUrlResponseStream",
            '400': "BadRequest",
            '401': "Unauthorized",
            '403': "Forbidden",
            '404': "NotFound",
            '409': "Conflict",
            '500': "InternalServerError",
        }
        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_credential_sets_accessed_urls_stream_with_http_info(
        self,
        credential_set_id: Annotated[Optional[StrictStr], Field(description="Search by credential set id.")] = None,
        credential_set_name: Annotated[Optional[StrictStr], Field(description="Search by credential set name.")] = None,
        accessed_url: Optional[StrictStr] = None,
        girs: Annotated[Optional[StrictStr], Field(description="Filter results by custom GIRs (General Intelligence Requirements), my_girs or company_pirs. Using multiple values will return results based on the aggregated GIR list")] = None,
        victim: Optional[StrictStr] = None,
        var_from: Annotated[Optional[StrictInt], Field(description="UNIX timestamp(in milliseconds)")] = None,
        until: Annotated[Optional[StrictInt], Field(description="UNIX timestamp(in milliseconds)")] = None,
        last_updated_from: Annotated[Optional[StrictStr], Field(description="UNIX timestamp(in milliseconds) or period e.g. 24hours or 7days")] = None,
        last_updated_until: Annotated[Optional[StrictStr], Field(description="UNIX timestamp(in milliseconds) or period e.g. 24hours or 7days")] = None,
        size: Annotated[Optional[StrictInt], Field(description="Range is: [1, 1000]")] = None,
        cursor: Annotated[Optional[StrictStr], Field(description="Continue scrolling from cursor")] = 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[GetCredSetAccessedUrlResponseStream]:
        """Credential set accessed url stream

        Returns list of Credential sets accessed urls matching filter criteria. The response contains “cursor_next” field, which should be provided to the next subsequent call to fetch potential next page of the results. Results are sorted by ascending order of the last_updated_ts field. Two indications of the end of the stream are possible: the result list is empty or its size is less than the requested items count.

        :param credential_set_id: Search by credential set id.
        :type credential_set_id: str
        :param credential_set_name: Search by credential set name.
        :type credential_set_name: str
        :param accessed_url:
        :type accessed_url: str
        :param girs: Filter results by custom GIRs (General Intelligence Requirements), my_girs or company_pirs. Using multiple values will return results based on the aggregated GIR list
        :type girs: str
        :param victim:
        :type victim: str
        :param var_from: UNIX timestamp(in milliseconds)
        :type var_from: int
        :param until: UNIX timestamp(in milliseconds)
        :type until: int
        :param last_updated_from: UNIX timestamp(in milliseconds) or period e.g. 24hours or 7days
        :type last_updated_from: str
        :param last_updated_until: UNIX timestamp(in milliseconds) or period e.g. 24hours or 7days
        :type last_updated_until: str
        :param size: Range is: [1, 1000]
        :type size: int
        :param cursor: Continue scrolling from cursor
        :type cursor: 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_credential_sets_accessed_urls_stream_serialize(
            credential_set_id=credential_set_id,
            credential_set_name=credential_set_name,
            accessed_url=accessed_url,
            girs=girs,
            victim=victim,
            var_from=var_from,
            until=until,
            last_updated_from=last_updated_from,
            last_updated_until=last_updated_until,
            size=size,
            cursor=cursor,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "GetCredSetAccessedUrlResponseStream",
            '400': "BadRequest",
            '401': "Unauthorized",
            '403': "Forbidden",
            '404': "NotFound",
            '409': "Conflict",
            '500': "InternalServerError",
        }
        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_credential_sets_accessed_urls_stream_without_preload_content(
        self,
        credential_set_id: Annotated[Optional[StrictStr], Field(description="Search by credential set id.")] = None,
        credential_set_name: Annotated[Optional[StrictStr], Field(description="Search by credential set name.")] = None,
        accessed_url: Optional[StrictStr] = None,
        girs: Annotated[Optional[StrictStr], Field(description="Filter results by custom GIRs (General Intelligence Requirements), my_girs or company_pirs. Using multiple values will return results based on the aggregated GIR list")] = None,
        victim: Optional[StrictStr] = None,
        var_from: Annotated[Optional[StrictInt], Field(description="UNIX timestamp(in milliseconds)")] = None,
        until: Annotated[Optional[StrictInt], Field(description="UNIX timestamp(in milliseconds)")] = None,
        last_updated_from: Annotated[Optional[StrictStr], Field(description="UNIX timestamp(in milliseconds) or period e.g. 24hours or 7days")] = None,
        last_updated_until: Annotated[Optional[StrictStr], Field(description="UNIX timestamp(in milliseconds) or period e.g. 24hours or 7days")] = None,
        size: Annotated[Optional[StrictInt], Field(description="Range is: [1, 1000]")] = None,
        cursor: Annotated[Optional[StrictStr], Field(description="Continue scrolling from cursor")] = 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:
        """Credential set accessed url stream

        Returns list of Credential sets accessed urls matching filter criteria. The response contains “cursor_next” field, which should be provided to the next subsequent call to fetch potential next page of the results. Results are sorted by ascending order of the last_updated_ts field. Two indications of the end of the stream are possible: the result list is empty or its size is less than the requested items count.

        :param credential_set_id: Search by credential set id.
        :type credential_set_id: str
        :param credential_set_name: Search by credential set name.
        :type credential_set_name: str
        :param accessed_url:
        :type accessed_url: str
        :param girs: Filter results by custom GIRs (General Intelligence Requirements), my_girs or company_pirs. Using multiple values will return results based on the aggregated GIR list
        :type girs: str
        :param victim:
        :type victim: str
        :param var_from: UNIX timestamp(in milliseconds)
        :type var_from: int
        :param until: UNIX timestamp(in milliseconds)
        :type until: int
        :param last_updated_from: UNIX timestamp(in milliseconds) or period e.g. 24hours or 7days
        :type last_updated_from: str
        :param last_updated_until: UNIX timestamp(in milliseconds) or period e.g. 24hours or 7days
        :type last_updated_until: str
        :param size: Range is: [1, 1000]
        :type size: int
        :param cursor: Continue scrolling from cursor
        :type cursor: 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_credential_sets_accessed_urls_stream_serialize(
            credential_set_id=credential_set_id,
            credential_set_name=credential_set_name,
            accessed_url=accessed_url,
            girs=girs,
            victim=victim,
            var_from=var_from,
            until=until,
            last_updated_from=last_updated_from,
            last_updated_until=last_updated_until,
            size=size,
            cursor=cursor,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "GetCredSetAccessedUrlResponseStream",
            '400': "BadRequest",
            '401': "Unauthorized",
            '403': "Forbidden",
            '404': "NotFound",
            '409': "Conflict",
            '500': "InternalServerError",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_credential_sets_accessed_urls_stream_serialize(
        self,
        credential_set_id,
        credential_set_name,
        accessed_url,
        girs,
        victim,
        var_from,
        until,
        last_updated_from,
        last_updated_until,
        size,
        cursor,
        _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
        if credential_set_id is not None:
            
            _query_params.append(('credential_set_id', credential_set_id))
            
        if credential_set_name is not None:
            
            _query_params.append(('credential_set_name', credential_set_name))
            
        if accessed_url is not None:
            
            _query_params.append(('accessed_url', accessed_url))
            
        if girs is not None:
            
            _query_params.append(('girs', girs))
            
        if victim is not None:
            
            _query_params.append(('victim', victim))
            
        if var_from is not None:
            
            _query_params.append(('from', var_from))
            
        if until is not None:
            
            _query_params.append(('until', until))
            
        if last_updated_from is not None:
            
            _query_params.append(('last_updated_from', last_updated_from))
            
        if last_updated_until is not None:
            
            _query_params.append(('last_updated_until', last_updated_until))
            
        if size is not None:
            
            _query_params.append(('size', size))
            
        if cursor is not None:
            
            _query_params.append(('cursor', cursor))
            
        # 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] = [
            'basicAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/integrations/creds/v1/credential-sets/accessed-urls/stream',
            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_credential_sets_id(
        self,
        id: Annotated[StrictStr, Field(description="ID of the credential set")],
        _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,
    ) -> GetCredSetResponse:
        """Get credential set by ID

        Returns a single Credential set matching requested ID.

        :param id: ID of the credential set (required)
        :type 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_credential_sets_id_serialize(
            id=id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "GetCredSetResponse",
            '400': "BadRequest",
            '401': "Unauthorized",
            '403': "Forbidden",
            '404': "NotFound",
            '409': "Conflict",
            '500': "InternalServerError",
        }
        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_credential_sets_id_with_http_info(
        self,
        id: Annotated[StrictStr, Field(description="ID of the credential set")],
        _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[GetCredSetResponse]:
        """Get credential set by ID

        Returns a single Credential set matching requested ID.

        :param id: ID of the credential set (required)
        :type 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_credential_sets_id_serialize(
            id=id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "GetCredSetResponse",
            '400': "BadRequest",
            '401': "Unauthorized",
            '403': "Forbidden",
            '404': "NotFound",
            '409': "Conflict",
            '500': "InternalServerError",
        }
        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_credential_sets_id_without_preload_content(
        self,
        id: Annotated[StrictStr, Field(description="ID of the credential set")],
        _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 credential set by ID

        Returns a single Credential set matching requested ID.

        :param id: ID of the credential set (required)
        :type 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_credential_sets_id_serialize(
            id=id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "GetCredSetResponse",
            '400': "BadRequest",
            '401': "Unauthorized",
            '403': "Forbidden",
            '404': "NotFound",
            '409': "Conflict",
            '500': "InternalServerError",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_credential_sets_id_serialize(
        self,
        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 id is not None:
            _path_params['id'] = 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] = [
            'basicAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/integrations/creds/v1/credential-sets/{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 get_credential_sets_stream(
        self,
        credential_set_name: Annotated[Optional[StrictStr], Field(description="Search by credential set name.")] = None,
        girs: Annotated[Optional[StrictStr], Field(description="Filter results by custom GIRs (General Intelligence Requirements), my_girs or company_pirs. Using multiple values will return results based on the aggregated GIR list")] = None,
        victim: Optional[StrictStr] = None,
        var_from: Annotated[Optional[StrictInt], Field(description="UNIX timestamp(in milliseconds)")] = None,
        until: Annotated[Optional[StrictInt], Field(description="UNIX timestamp(in milliseconds)")] = None,
        last_updated_from: Annotated[Optional[StrictStr], Field(description="UNIX timestamp(in milliseconds) or period e.g. 24hours or 7days")] = None,
        last_updated_until: Annotated[Optional[StrictStr], Field(description="UNIX timestamp(in milliseconds) or period e.g. 24hours or 7days")] = None,
        size: Annotated[Optional[StrictInt], Field(description="Range is: [1, 1000]")] = None,
        cursor: Annotated[Optional[StrictStr], Field(description="Continue scrolling from cursor")] = 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,
    ) -> GetCredSetResponseStream:
        """Credential set stream

        Returns list of Credential sets matching filter criteria. The response contains “cursor_next” field, which should be provided to the next subsequent call to fetch potential next page of the results. Results are sorted by ascending order of the last_updated_ts field. Two indications of the end of the stream are possible: the result list is empty or its size is less than the requested items count.

        :param credential_set_name: Search by credential set name.
        :type credential_set_name: str
        :param girs: Filter results by custom GIRs (General Intelligence Requirements), my_girs or company_pirs. Using multiple values will return results based on the aggregated GIR list
        :type girs: str
        :param victim:
        :type victim: str
        :param var_from: UNIX timestamp(in milliseconds)
        :type var_from: int
        :param until: UNIX timestamp(in milliseconds)
        :type until: int
        :param last_updated_from: UNIX timestamp(in milliseconds) or period e.g. 24hours or 7days
        :type last_updated_from: str
        :param last_updated_until: UNIX timestamp(in milliseconds) or period e.g. 24hours or 7days
        :type last_updated_until: str
        :param size: Range is: [1, 1000]
        :type size: int
        :param cursor: Continue scrolling from cursor
        :type cursor: 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_credential_sets_stream_serialize(
            credential_set_name=credential_set_name,
            girs=girs,
            victim=victim,
            var_from=var_from,
            until=until,
            last_updated_from=last_updated_from,
            last_updated_until=last_updated_until,
            size=size,
            cursor=cursor,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "GetCredSetResponseStream",
            '400': "BadRequest",
            '401': "Unauthorized",
            '403': "Forbidden",
            '404': "NotFound",
            '409': "Conflict",
            '500': "InternalServerError",
        }
        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_credential_sets_stream_with_http_info(
        self,
        credential_set_name: Annotated[Optional[StrictStr], Field(description="Search by credential set name.")] = None,
        girs: Annotated[Optional[StrictStr], Field(description="Filter results by custom GIRs (General Intelligence Requirements), my_girs or company_pirs. Using multiple values will return results based on the aggregated GIR list")] = None,
        victim: Optional[StrictStr] = None,
        var_from: Annotated[Optional[StrictInt], Field(description="UNIX timestamp(in milliseconds)")] = None,
        until: Annotated[Optional[StrictInt], Field(description="UNIX timestamp(in milliseconds)")] = None,
        last_updated_from: Annotated[Optional[StrictStr], Field(description="UNIX timestamp(in milliseconds) or period e.g. 24hours or 7days")] = None,
        last_updated_until: Annotated[Optional[StrictStr], Field(description="UNIX timestamp(in milliseconds) or period e.g. 24hours or 7days")] = None,
        size: Annotated[Optional[StrictInt], Field(description="Range is: [1, 1000]")] = None,
        cursor: Annotated[Optional[StrictStr], Field(description="Continue scrolling from cursor")] = 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[GetCredSetResponseStream]:
        """Credential set stream

        Returns list of Credential sets matching filter criteria. The response contains “cursor_next” field, which should be provided to the next subsequent call to fetch potential next page of the results. Results are sorted by ascending order of the last_updated_ts field. Two indications of the end of the stream are possible: the result list is empty or its size is less than the requested items count.

        :param credential_set_name: Search by credential set name.
        :type credential_set_name: str
        :param girs: Filter results by custom GIRs (General Intelligence Requirements), my_girs or company_pirs. Using multiple values will return results based on the aggregated GIR list
        :type girs: str
        :param victim:
        :type victim: str
        :param var_from: UNIX timestamp(in milliseconds)
        :type var_from: int
        :param until: UNIX timestamp(in milliseconds)
        :type until: int
        :param last_updated_from: UNIX timestamp(in milliseconds) or period e.g. 24hours or 7days
        :type last_updated_from: str
        :param last_updated_until: UNIX timestamp(in milliseconds) or period e.g. 24hours or 7days
        :type last_updated_until: str
        :param size: Range is: [1, 1000]
        :type size: int
        :param cursor: Continue scrolling from cursor
        :type cursor: 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_credential_sets_stream_serialize(
            credential_set_name=credential_set_name,
            girs=girs,
            victim=victim,
            var_from=var_from,
            until=until,
            last_updated_from=last_updated_from,
            last_updated_until=last_updated_until,
            size=size,
            cursor=cursor,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "GetCredSetResponseStream",
            '400': "BadRequest",
            '401': "Unauthorized",
            '403': "Forbidden",
            '404': "NotFound",
            '409': "Conflict",
            '500': "InternalServerError",
        }
        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_credential_sets_stream_without_preload_content(
        self,
        credential_set_name: Annotated[Optional[StrictStr], Field(description="Search by credential set name.")] = None,
        girs: Annotated[Optional[StrictStr], Field(description="Filter results by custom GIRs (General Intelligence Requirements), my_girs or company_pirs. Using multiple values will return results based on the aggregated GIR list")] = None,
        victim: Optional[StrictStr] = None,
        var_from: Annotated[Optional[StrictInt], Field(description="UNIX timestamp(in milliseconds)")] = None,
        until: Annotated[Optional[StrictInt], Field(description="UNIX timestamp(in milliseconds)")] = None,
        last_updated_from: Annotated[Optional[StrictStr], Field(description="UNIX timestamp(in milliseconds) or period e.g. 24hours or 7days")] = None,
        last_updated_until: Annotated[Optional[StrictStr], Field(description="UNIX timestamp(in milliseconds) or period e.g. 24hours or 7days")] = None,
        size: Annotated[Optional[StrictInt], Field(description="Range is: [1, 1000]")] = None,
        cursor: Annotated[Optional[StrictStr], Field(description="Continue scrolling from cursor")] = 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:
        """Credential set stream

        Returns list of Credential sets matching filter criteria. The response contains “cursor_next” field, which should be provided to the next subsequent call to fetch potential next page of the results. Results are sorted by ascending order of the last_updated_ts field. Two indications of the end of the stream are possible: the result list is empty or its size is less than the requested items count.

        :param credential_set_name: Search by credential set name.
        :type credential_set_name: str
        :param girs: Filter results by custom GIRs (General Intelligence Requirements), my_girs or company_pirs. Using multiple values will return results based on the aggregated GIR list
        :type girs: str
        :param victim:
        :type victim: str
        :param var_from: UNIX timestamp(in milliseconds)
        :type var_from: int
        :param until: UNIX timestamp(in milliseconds)
        :type until: int
        :param last_updated_from: UNIX timestamp(in milliseconds) or period e.g. 24hours or 7days
        :type last_updated_from: str
        :param last_updated_until: UNIX timestamp(in milliseconds) or period e.g. 24hours or 7days
        :type last_updated_until: str
        :param size: Range is: [1, 1000]
        :type size: int
        :param cursor: Continue scrolling from cursor
        :type cursor: 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_credential_sets_stream_serialize(
            credential_set_name=credential_set_name,
            girs=girs,
            victim=victim,
            var_from=var_from,
            until=until,
            last_updated_from=last_updated_from,
            last_updated_until=last_updated_until,
            size=size,
            cursor=cursor,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "GetCredSetResponseStream",
            '400': "BadRequest",
            '401': "Unauthorized",
            '403': "Forbidden",
            '404': "NotFound",
            '409': "Conflict",
            '500': "InternalServerError",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_credential_sets_stream_serialize(
        self,
        credential_set_name,
        girs,
        victim,
        var_from,
        until,
        last_updated_from,
        last_updated_until,
        size,
        cursor,
        _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
        if credential_set_name is not None:
            
            _query_params.append(('credential_set_name', credential_set_name))
            
        if girs is not None:
            
            _query_params.append(('girs', girs))
            
        if victim is not None:
            
            _query_params.append(('victim', victim))
            
        if var_from is not None:
            
            _query_params.append(('from', var_from))
            
        if until is not None:
            
            _query_params.append(('until', until))
            
        if last_updated_from is not None:
            
            _query_params.append(('last_updated_from', last_updated_from))
            
        if last_updated_until is not None:
            
            _query_params.append(('last_updated_until', last_updated_until))
            
        if size is not None:
            
            _query_params.append(('size', size))
            
        if cursor is not None:
            
            _query_params.append(('cursor', cursor))
            
        # 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] = [
            'basicAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/integrations/creds/v1/credential-sets/stream',
            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_credentials_id(
        self,
        id: Annotated[StrictStr, Field(description="ID of the credential")],
        _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,
    ) -> GetCredResponse:
        """Get credential by ID

        Returns a single Credential matching requested ID.

        :param id: ID of the credential (required)
        :type 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_credentials_id_serialize(
            id=id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "GetCredResponse",
            '400': "BadRequest",
            '401': "Unauthorized",
            '403': "Forbidden",
            '404': "NotFound",
            '409': "Conflict",
            '500': "InternalServerError",
        }
        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_credentials_id_with_http_info(
        self,
        id: Annotated[StrictStr, Field(description="ID of the credential")],
        _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[GetCredResponse]:
        """Get credential by ID

        Returns a single Credential matching requested ID.

        :param id: ID of the credential (required)
        :type 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_credentials_id_serialize(
            id=id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "GetCredResponse",
            '400': "BadRequest",
            '401': "Unauthorized",
            '403': "Forbidden",
            '404': "NotFound",
            '409': "Conflict",
            '500': "InternalServerError",
        }
        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_credentials_id_without_preload_content(
        self,
        id: Annotated[StrictStr, Field(description="ID of the credential")],
        _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 credential by ID

        Returns a single Credential matching requested ID.

        :param id: ID of the credential (required)
        :type 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_credentials_id_serialize(
            id=id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "GetCredResponse",
            '400': "BadRequest",
            '401': "Unauthorized",
            '403': "Forbidden",
            '404': "NotFound",
            '409': "Conflict",
            '500': "InternalServerError",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_credentials_id_serialize(
        self,
        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 id is not None:
            _path_params['id'] = 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] = [
            'basicAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/integrations/creds/v1/credentials/{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 get_credentials_occurrences_id(
        self,
        id: Annotated[StrictStr, Field(description="ID of the credential occurrence")],
        _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,
    ) -> GetCredOccurrenceResponse:
        """Get credential occurrence by ID

        Returns a single Credential occurrence matching requested ID.

        :param id: ID of the credential occurrence (required)
        :type 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_credentials_occurrences_id_serialize(
            id=id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "GetCredOccurrenceResponse",
            '400': "BadRequest",
            '401': "Unauthorized",
            '403': "Forbidden",
            '404': "NotFound",
            '409': "Conflict",
            '500': "InternalServerError",
        }
        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_credentials_occurrences_id_with_http_info(
        self,
        id: Annotated[StrictStr, Field(description="ID of the credential occurrence")],
        _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[GetCredOccurrenceResponse]:
        """Get credential occurrence by ID

        Returns a single Credential occurrence matching requested ID.

        :param id: ID of the credential occurrence (required)
        :type 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_credentials_occurrences_id_serialize(
            id=id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "GetCredOccurrenceResponse",
            '400': "BadRequest",
            '401': "Unauthorized",
            '403': "Forbidden",
            '404': "NotFound",
            '409': "Conflict",
            '500': "InternalServerError",
        }
        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_credentials_occurrences_id_without_preload_content(
        self,
        id: Annotated[StrictStr, Field(description="ID of the credential occurrence")],
        _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 credential occurrence by ID

        Returns a single Credential occurrence matching requested ID.

        :param id: ID of the credential occurrence (required)
        :type 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_credentials_occurrences_id_serialize(
            id=id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "GetCredOccurrenceResponse",
            '400': "BadRequest",
            '401': "Unauthorized",
            '403': "Forbidden",
            '404': "NotFound",
            '409': "Conflict",
            '500': "InternalServerError",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_credentials_occurrences_id_serialize(
        self,
        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 id is not None:
            _path_params['id'] = 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] = [
            'basicAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/integrations/creds/v1/credentials/occurrences/{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 get_credentials_occurrences_stream(
        self,
        credential_id: Annotated[Optional[StrictStr], Field(description="Search by credential id.")] = None,
        credential_set_name: Annotated[Optional[StrictStr], Field(description="Search by credential set name.")] = None,
        credential_set_id: Annotated[Optional[StrictStr], Field(description="Search by credential set id.")] = None,
        domain: Annotated[Optional[StrictStr], Field(description="Search by credential domain(detection domain).")] = None,
        affiliation_group: Annotated[Optional[StrictStr], Field(description="Possible values: my_employees, my_customers, third_parties, vip_emails")] = None,
        password_strength: Annotated[Optional[StrictStr], Field(description="Possible values: excellent, strong, medium, weak, poor, not_provided")] = None,
        password_length_gte: Annotated[Optional[StrictInt], Field(description="Must be greater than or equal to 0")] = None,
        password_lowercase_gte: Annotated[Optional[StrictInt], Field(description="Must be greater than or equal to 0")] = None,
        password_uppercase_gte: Annotated[Optional[StrictInt], Field(description="Must be greater than or equal to 0")] = None,
        password_numbers_gte: Annotated[Optional[StrictInt], Field(description="Must be greater than or equal to 0")] = None,
        password_punctuation_gte: Annotated[Optional[StrictInt], Field(description="Must be greater than or equal to 0")] = None,
        password_symbols_gte: Annotated[Optional[StrictInt], Field(description="Must be greater than or equal to 0")] = None,
        password_separators_gte: Annotated[Optional[StrictInt], Field(description="Must be greater than or equal to 0")] = None,
        password_other_gte: Annotated[Optional[StrictInt], Field(description="Must be greater than or equal to 0")] = None,
        password_entropy_gte: Annotated[Optional[StrictInt], Field(description="Must be greater than or equal to 0")] = None,
        password_plain: Annotated[Optional[StrictStr], Field(description="Must be URL encoded")] = None,
        credential_login: Annotated[Optional[StrictStr], Field(description="Search by credential login.")] = None,
        detected_malware: Annotated[Optional[StrictStr], Field(description="Search by credential detected malware. For example: agent_tesla, Lumma, VIDAR")] = None,
        girs: Annotated[Optional[StrictStr], Field(description="Filter results by custom GIRs (General Intelligence Requirements), my_girs or company_pirs. Using multiple values will return results based on the aggregated GIR list")] = None,
        var_from: Annotated[Optional[StrictInt], Field(description="UNIX timestamp(in milliseconds)")] = None,
        until: Annotated[Optional[StrictInt], Field(description="UNIX timestamp(in milliseconds)")] = None,
        last_updated_from: Annotated[Optional[StrictStr], Field(description="UNIX timestamp(in milliseconds) or period e.g. 24hours or 7days")] = None,
        last_updated_until: Annotated[Optional[StrictStr], Field(description="UNIX timestamp(in milliseconds) or period e.g. 24hours or 7days")] = None,
        size: Annotated[Optional[StrictInt], Field(description="Range is: [1, 1000]")] = None,
        cursor: Annotated[Optional[StrictStr], Field(description="Continue scrolling from cursor")] = 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,
    ) -> GetCredOccurrenceResponseStream:
        """Credential occurrence stream

        Returns list of Credential occurrences matching filter criteria. Stream pagination is based on a cursor. The response is the same as for the /credentials/occurrences endpoint but with the additional “cursorNext” field. Results are sorted by ascending order of the lastUpdated field. Two indications of the end of the stream are possible: the result list is empty or its size is less than the requested items count.

        :param credential_id: Search by credential id.
        :type credential_id: str
        :param credential_set_name: Search by credential set name.
        :type credential_set_name: str
        :param credential_set_id: Search by credential set id.
        :type credential_set_id: str
        :param domain: Search by credential domain(detection domain).
        :type domain: str
        :param affiliation_group: Possible values: my_employees, my_customers, third_parties, vip_emails
        :type affiliation_group: str
        :param password_strength: Possible values: excellent, strong, medium, weak, poor, not_provided
        :type password_strength: str
        :param password_length_gte: Must be greater than or equal to 0
        :type password_length_gte: int
        :param password_lowercase_gte: Must be greater than or equal to 0
        :type password_lowercase_gte: int
        :param password_uppercase_gte: Must be greater than or equal to 0
        :type password_uppercase_gte: int
        :param password_numbers_gte: Must be greater than or equal to 0
        :type password_numbers_gte: int
        :param password_punctuation_gte: Must be greater than or equal to 0
        :type password_punctuation_gte: int
        :param password_symbols_gte: Must be greater than or equal to 0
        :type password_symbols_gte: int
        :param password_separators_gte: Must be greater than or equal to 0
        :type password_separators_gte: int
        :param password_other_gte: Must be greater than or equal to 0
        :type password_other_gte: int
        :param password_entropy_gte: Must be greater than or equal to 0
        :type password_entropy_gte: int
        :param password_plain: Must be URL encoded
        :type password_plain: str
        :param credential_login: Search by credential login.
        :type credential_login: str
        :param detected_malware: Search by credential detected malware. For example: agent_tesla, Lumma, VIDAR
        :type detected_malware: str
        :param girs: Filter results by custom GIRs (General Intelligence Requirements), my_girs or company_pirs. Using multiple values will return results based on the aggregated GIR list
        :type girs: str
        :param var_from: UNIX timestamp(in milliseconds)
        :type var_from: int
        :param until: UNIX timestamp(in milliseconds)
        :type until: int
        :param last_updated_from: UNIX timestamp(in milliseconds) or period e.g. 24hours or 7days
        :type last_updated_from: str
        :param last_updated_until: UNIX timestamp(in milliseconds) or period e.g. 24hours or 7days
        :type last_updated_until: str
        :param size: Range is: [1, 1000]
        :type size: int
        :param cursor: Continue scrolling from cursor
        :type cursor: 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_credentials_occurrences_stream_serialize(
            credential_id=credential_id,
            credential_set_name=credential_set_name,
            credential_set_id=credential_set_id,
            domain=domain,
            affiliation_group=affiliation_group,
            password_strength=password_strength,
            password_length_gte=password_length_gte,
            password_lowercase_gte=password_lowercase_gte,
            password_uppercase_gte=password_uppercase_gte,
            password_numbers_gte=password_numbers_gte,
            password_punctuation_gte=password_punctuation_gte,
            password_symbols_gte=password_symbols_gte,
            password_separators_gte=password_separators_gte,
            password_other_gte=password_other_gte,
            password_entropy_gte=password_entropy_gte,
            password_plain=password_plain,
            credential_login=credential_login,
            detected_malware=detected_malware,
            girs=girs,
            var_from=var_from,
            until=until,
            last_updated_from=last_updated_from,
            last_updated_until=last_updated_until,
            size=size,
            cursor=cursor,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "GetCredOccurrenceResponseStream",
            '400': "BadRequest",
            '401': "Unauthorized",
            '403': "Forbidden",
            '404': "NotFound",
            '409': "Conflict",
            '500': "InternalServerError",
        }
        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_credentials_occurrences_stream_with_http_info(
        self,
        credential_id: Annotated[Optional[StrictStr], Field(description="Search by credential id.")] = None,
        credential_set_name: Annotated[Optional[StrictStr], Field(description="Search by credential set name.")] = None,
        credential_set_id: Annotated[Optional[StrictStr], Field(description="Search by credential set id.")] = None,
        domain: Annotated[Optional[StrictStr], Field(description="Search by credential domain(detection domain).")] = None,
        affiliation_group: Annotated[Optional[StrictStr], Field(description="Possible values: my_employees, my_customers, third_parties, vip_emails")] = None,
        password_strength: Annotated[Optional[StrictStr], Field(description="Possible values: excellent, strong, medium, weak, poor, not_provided")] = None,
        password_length_gte: Annotated[Optional[StrictInt], Field(description="Must be greater than or equal to 0")] = None,
        password_lowercase_gte: Annotated[Optional[StrictInt], Field(description="Must be greater than or equal to 0")] = None,
        password_uppercase_gte: Annotated[Optional[StrictInt], Field(description="Must be greater than or equal to 0")] = None,
        password_numbers_gte: Annotated[Optional[StrictInt], Field(description="Must be greater than or equal to 0")] = None,
        password_punctuation_gte: Annotated[Optional[StrictInt], Field(description="Must be greater than or equal to 0")] = None,
        password_symbols_gte: Annotated[Optional[StrictInt], Field(description="Must be greater than or equal to 0")] = None,
        password_separators_gte: Annotated[Optional[StrictInt], Field(description="Must be greater than or equal to 0")] = None,
        password_other_gte: Annotated[Optional[StrictInt], Field(description="Must be greater than or equal to 0")] = None,
        password_entropy_gte: Annotated[Optional[StrictInt], Field(description="Must be greater than or equal to 0")] = None,
        password_plain: Annotated[Optional[StrictStr], Field(description="Must be URL encoded")] = None,
        credential_login: Annotated[Optional[StrictStr], Field(description="Search by credential login.")] = None,
        detected_malware: Annotated[Optional[StrictStr], Field(description="Search by credential detected malware. For example: agent_tesla, Lumma, VIDAR")] = None,
        girs: Annotated[Optional[StrictStr], Field(description="Filter results by custom GIRs (General Intelligence Requirements), my_girs or company_pirs. Using multiple values will return results based on the aggregated GIR list")] = None,
        var_from: Annotated[Optional[StrictInt], Field(description="UNIX timestamp(in milliseconds)")] = None,
        until: Annotated[Optional[StrictInt], Field(description="UNIX timestamp(in milliseconds)")] = None,
        last_updated_from: Annotated[Optional[StrictStr], Field(description="UNIX timestamp(in milliseconds) or period e.g. 24hours or 7days")] = None,
        last_updated_until: Annotated[Optional[StrictStr], Field(description="UNIX timestamp(in milliseconds) or period e.g. 24hours or 7days")] = None,
        size: Annotated[Optional[StrictInt], Field(description="Range is: [1, 1000]")] = None,
        cursor: Annotated[Optional[StrictStr], Field(description="Continue scrolling from cursor")] = 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[GetCredOccurrenceResponseStream]:
        """Credential occurrence stream

        Returns list of Credential occurrences matching filter criteria. Stream pagination is based on a cursor. The response is the same as for the /credentials/occurrences endpoint but with the additional “cursorNext” field. Results are sorted by ascending order of the lastUpdated field. Two indications of the end of the stream are possible: the result list is empty or its size is less than the requested items count.

        :param credential_id: Search by credential id.
        :type credential_id: str
        :param credential_set_name: Search by credential set name.
        :type credential_set_name: str
        :param credential_set_id: Search by credential set id.
        :type credential_set_id: str
        :param domain: Search by credential domain(detection domain).
        :type domain: str
        :param affiliation_group: Possible values: my_employees, my_customers, third_parties, vip_emails
        :type affiliation_group: str
        :param password_strength: Possible values: excellent, strong, medium, weak, poor, not_provided
        :type password_strength: str
        :param password_length_gte: Must be greater than or equal to 0
        :type password_length_gte: int
        :param password_lowercase_gte: Must be greater than or equal to 0
        :type password_lowercase_gte: int
        :param password_uppercase_gte: Must be greater than or equal to 0
        :type password_uppercase_gte: int
        :param password_numbers_gte: Must be greater than or equal to 0
        :type password_numbers_gte: int
        :param password_punctuation_gte: Must be greater than or equal to 0
        :type password_punctuation_gte: int
        :param password_symbols_gte: Must be greater than or equal to 0
        :type password_symbols_gte: int
        :param password_separators_gte: Must be greater than or equal to 0
        :type password_separators_gte: int
        :param password_other_gte: Must be greater than or equal to 0
        :type password_other_gte: int
        :param password_entropy_gte: Must be greater than or equal to 0
        :type password_entropy_gte: int
        :param password_plain: Must be URL encoded
        :type password_plain: str
        :param credential_login: Search by credential login.
        :type credential_login: str
        :param detected_malware: Search by credential detected malware. For example: agent_tesla, Lumma, VIDAR
        :type detected_malware: str
        :param girs: Filter results by custom GIRs (General Intelligence Requirements), my_girs or company_pirs. Using multiple values will return results based on the aggregated GIR list
        :type girs: str
        :param var_from: UNIX timestamp(in milliseconds)
        :type var_from: int
        :param until: UNIX timestamp(in milliseconds)
        :type until: int
        :param last_updated_from: UNIX timestamp(in milliseconds) or period e.g. 24hours or 7days
        :type last_updated_from: str
        :param last_updated_until: UNIX timestamp(in milliseconds) or period e.g. 24hours or 7days
        :type last_updated_until: str
        :param size: Range is: [1, 1000]
        :type size: int
        :param cursor: Continue scrolling from cursor
        :type cursor: 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_credentials_occurrences_stream_serialize(
            credential_id=credential_id,
            credential_set_name=credential_set_name,
            credential_set_id=credential_set_id,
            domain=domain,
            affiliation_group=affiliation_group,
            password_strength=password_strength,
            password_length_gte=password_length_gte,
            password_lowercase_gte=password_lowercase_gte,
            password_uppercase_gte=password_uppercase_gte,
            password_numbers_gte=password_numbers_gte,
            password_punctuation_gte=password_punctuation_gte,
            password_symbols_gte=password_symbols_gte,
            password_separators_gte=password_separators_gte,
            password_other_gte=password_other_gte,
            password_entropy_gte=password_entropy_gte,
            password_plain=password_plain,
            credential_login=credential_login,
            detected_malware=detected_malware,
            girs=girs,
            var_from=var_from,
            until=until,
            last_updated_from=last_updated_from,
            last_updated_until=last_updated_until,
            size=size,
            cursor=cursor,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "GetCredOccurrenceResponseStream",
            '400': "BadRequest",
            '401': "Unauthorized",
            '403': "Forbidden",
            '404': "NotFound",
            '409': "Conflict",
            '500': "InternalServerError",
        }
        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_credentials_occurrences_stream_without_preload_content(
        self,
        credential_id: Annotated[Optional[StrictStr], Field(description="Search by credential id.")] = None,
        credential_set_name: Annotated[Optional[StrictStr], Field(description="Search by credential set name.")] = None,
        credential_set_id: Annotated[Optional[StrictStr], Field(description="Search by credential set id.")] = None,
        domain: Annotated[Optional[StrictStr], Field(description="Search by credential domain(detection domain).")] = None,
        affiliation_group: Annotated[Optional[StrictStr], Field(description="Possible values: my_employees, my_customers, third_parties, vip_emails")] = None,
        password_strength: Annotated[Optional[StrictStr], Field(description="Possible values: excellent, strong, medium, weak, poor, not_provided")] = None,
        password_length_gte: Annotated[Optional[StrictInt], Field(description="Must be greater than or equal to 0")] = None,
        password_lowercase_gte: Annotated[Optional[StrictInt], Field(description="Must be greater than or equal to 0")] = None,
        password_uppercase_gte: Annotated[Optional[StrictInt], Field(description="Must be greater than or equal to 0")] = None,
        password_numbers_gte: Annotated[Optional[StrictInt], Field(description="Must be greater than or equal to 0")] = None,
        password_punctuation_gte: Annotated[Optional[StrictInt], Field(description="Must be greater than or equal to 0")] = None,
        password_symbols_gte: Annotated[Optional[StrictInt], Field(description="Must be greater than or equal to 0")] = None,
        password_separators_gte: Annotated[Optional[StrictInt], Field(description="Must be greater than or equal to 0")] = None,
        password_other_gte: Annotated[Optional[StrictInt], Field(description="Must be greater than or equal to 0")] = None,
        password_entropy_gte: Annotated[Optional[StrictInt], Field(description="Must be greater than or equal to 0")] = None,
        password_plain: Annotated[Optional[StrictStr], Field(description="Must be URL encoded")] = None,
        credential_login: Annotated[Optional[StrictStr], Field(description="Search by credential login.")] = None,
        detected_malware: Annotated[Optional[StrictStr], Field(description="Search by credential detected malware. For example: agent_tesla, Lumma, VIDAR")] = None,
        girs: Annotated[Optional[StrictStr], Field(description="Filter results by custom GIRs (General Intelligence Requirements), my_girs or company_pirs. Using multiple values will return results based on the aggregated GIR list")] = None,
        var_from: Annotated[Optional[StrictInt], Field(description="UNIX timestamp(in milliseconds)")] = None,
        until: Annotated[Optional[StrictInt], Field(description="UNIX timestamp(in milliseconds)")] = None,
        last_updated_from: Annotated[Optional[StrictStr], Field(description="UNIX timestamp(in milliseconds) or period e.g. 24hours or 7days")] = None,
        last_updated_until: Annotated[Optional[StrictStr], Field(description="UNIX timestamp(in milliseconds) or period e.g. 24hours or 7days")] = None,
        size: Annotated[Optional[StrictInt], Field(description="Range is: [1, 1000]")] = None,
        cursor: Annotated[Optional[StrictStr], Field(description="Continue scrolling from cursor")] = 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:
        """Credential occurrence stream

        Returns list of Credential occurrences matching filter criteria. Stream pagination is based on a cursor. The response is the same as for the /credentials/occurrences endpoint but with the additional “cursorNext” field. Results are sorted by ascending order of the lastUpdated field. Two indications of the end of the stream are possible: the result list is empty or its size is less than the requested items count.

        :param credential_id: Search by credential id.
        :type credential_id: str
        :param credential_set_name: Search by credential set name.
        :type credential_set_name: str
        :param credential_set_id: Search by credential set id.
        :type credential_set_id: str
        :param domain: Search by credential domain(detection domain).
        :type domain: str
        :param affiliation_group: Possible values: my_employees, my_customers, third_parties, vip_emails
        :type affiliation_group: str
        :param password_strength: Possible values: excellent, strong, medium, weak, poor, not_provided
        :type password_strength: str
        :param password_length_gte: Must be greater than or equal to 0
        :type password_length_gte: int
        :param password_lowercase_gte: Must be greater than or equal to 0
        :type password_lowercase_gte: int
        :param password_uppercase_gte: Must be greater than or equal to 0
        :type password_uppercase_gte: int
        :param password_numbers_gte: Must be greater than or equal to 0
        :type password_numbers_gte: int
        :param password_punctuation_gte: Must be greater than or equal to 0
        :type password_punctuation_gte: int
        :param password_symbols_gte: Must be greater than or equal to 0
        :type password_symbols_gte: int
        :param password_separators_gte: Must be greater than or equal to 0
        :type password_separators_gte: int
        :param password_other_gte: Must be greater than or equal to 0
        :type password_other_gte: int
        :param password_entropy_gte: Must be greater than or equal to 0
        :type password_entropy_gte: int
        :param password_plain: Must be URL encoded
        :type password_plain: str
        :param credential_login: Search by credential login.
        :type credential_login: str
        :param detected_malware: Search by credential detected malware. For example: agent_tesla, Lumma, VIDAR
        :type detected_malware: str
        :param girs: Filter results by custom GIRs (General Intelligence Requirements), my_girs or company_pirs. Using multiple values will return results based on the aggregated GIR list
        :type girs: str
        :param var_from: UNIX timestamp(in milliseconds)
        :type var_from: int
        :param until: UNIX timestamp(in milliseconds)
        :type until: int
        :param last_updated_from: UNIX timestamp(in milliseconds) or period e.g. 24hours or 7days
        :type last_updated_from: str
        :param last_updated_until: UNIX timestamp(in milliseconds) or period e.g. 24hours or 7days
        :type last_updated_until: str
        :param size: Range is: [1, 1000]
        :type size: int
        :param cursor: Continue scrolling from cursor
        :type cursor: 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_credentials_occurrences_stream_serialize(
            credential_id=credential_id,
            credential_set_name=credential_set_name,
            credential_set_id=credential_set_id,
            domain=domain,
            affiliation_group=affiliation_group,
            password_strength=password_strength,
            password_length_gte=password_length_gte,
            password_lowercase_gte=password_lowercase_gte,
            password_uppercase_gte=password_uppercase_gte,
            password_numbers_gte=password_numbers_gte,
            password_punctuation_gte=password_punctuation_gte,
            password_symbols_gte=password_symbols_gte,
            password_separators_gte=password_separators_gte,
            password_other_gte=password_other_gte,
            password_entropy_gte=password_entropy_gte,
            password_plain=password_plain,
            credential_login=credential_login,
            detected_malware=detected_malware,
            girs=girs,
            var_from=var_from,
            until=until,
            last_updated_from=last_updated_from,
            last_updated_until=last_updated_until,
            size=size,
            cursor=cursor,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "GetCredOccurrenceResponseStream",
            '400': "BadRequest",
            '401': "Unauthorized",
            '403': "Forbidden",
            '404': "NotFound",
            '409': "Conflict",
            '500': "InternalServerError",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_credentials_occurrences_stream_serialize(
        self,
        credential_id,
        credential_set_name,
        credential_set_id,
        domain,
        affiliation_group,
        password_strength,
        password_length_gte,
        password_lowercase_gte,
        password_uppercase_gte,
        password_numbers_gte,
        password_punctuation_gte,
        password_symbols_gte,
        password_separators_gte,
        password_other_gte,
        password_entropy_gte,
        password_plain,
        credential_login,
        detected_malware,
        girs,
        var_from,
        until,
        last_updated_from,
        last_updated_until,
        size,
        cursor,
        _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
        if credential_id is not None:
            
            _query_params.append(('credential_id', credential_id))
            
        if credential_set_name is not None:
            
            _query_params.append(('credential_set_name', credential_set_name))
            
        if credential_set_id is not None:
            
            _query_params.append(('credential_set_id', credential_set_id))
            
        if domain is not None:
            
            _query_params.append(('domain', domain))
            
        if affiliation_group is not None:
            
            _query_params.append(('affiliation_group', affiliation_group))
            
        if password_strength is not None:
            
            _query_params.append(('password_strength', password_strength))
            
        if password_length_gte is not None:
            
            _query_params.append(('password_length_gte', password_length_gte))
            
        if password_lowercase_gte is not None:
            
            _query_params.append(('password_lowercase_gte', password_lowercase_gte))
            
        if password_uppercase_gte is not None:
            
            _query_params.append(('password_uppercase_gte', password_uppercase_gte))
            
        if password_numbers_gte is not None:
            
            _query_params.append(('password_numbers_gte', password_numbers_gte))
            
        if password_punctuation_gte is not None:
            
            _query_params.append(('password_punctuation_gte', password_punctuation_gte))
            
        if password_symbols_gte is not None:
            
            _query_params.append(('password_symbols_gte', password_symbols_gte))
            
        if password_separators_gte is not None:
            
            _query_params.append(('password_separators_gte', password_separators_gte))
            
        if password_other_gte is not None:
            
            _query_params.append(('password_other_gte', password_other_gte))
            
        if password_entropy_gte is not None:
            
            _query_params.append(('password_entropy_gte', password_entropy_gte))
            
        if password_plain is not None:
            
            _query_params.append(('password_plain', password_plain))
            
        if credential_login is not None:
            
            _query_params.append(('credential_login', credential_login))
            
        if detected_malware is not None:
            
            _query_params.append(('detected_malware', detected_malware))
            
        if girs is not None:
            
            _query_params.append(('girs', girs))
            
        if var_from is not None:
            
            _query_params.append(('from', var_from))
            
        if until is not None:
            
            _query_params.append(('until', until))
            
        if last_updated_from is not None:
            
            _query_params.append(('last_updated_from', last_updated_from))
            
        if last_updated_until is not None:
            
            _query_params.append(('last_updated_until', last_updated_until))
            
        if size is not None:
            
            _query_params.append(('size', size))
            
        if cursor is not None:
            
            _query_params.append(('cursor', cursor))
            
        # 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] = [
            'basicAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/integrations/creds/v1/credentials/occurrences/stream',
            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_credentials_stream(
        self,
        credential_set_name: Annotated[Optional[StrictStr], Field(description="Search by credential set name.")] = None,
        credential_set_id: Annotated[Optional[StrictStr], Field(description="Search by credential set id.")] = None,
        domain: Annotated[Optional[StrictStr], Field(description="Search by credential domain(detection domain).")] = None,
        affiliation_group: Annotated[Optional[StrictStr], Field(description="Possible values: my_employees, my_customers, third_parties, vip_emails")] = None,
        password_strength: Annotated[Optional[StrictStr], Field(description="Possible values: excellent, strong, medium, weak, poor, not_provided")] = None,
        password_length_gte: Annotated[Optional[StrictInt], Field(description="Must be greater than or equal to 0")] = None,
        password_lowercase_gte: Annotated[Optional[StrictInt], Field(description="Must be greater than or equal to 0")] = None,
        password_uppercase_gte: Annotated[Optional[StrictInt], Field(description="Must be greater than or equal to 0")] = None,
        password_numbers_gte: Annotated[Optional[StrictInt], Field(description="Must be greater than or equal to 0")] = None,
        password_punctuation_gte: Annotated[Optional[StrictInt], Field(description="Must be greater than or equal to 0")] = None,
        password_symbols_gte: Annotated[Optional[StrictInt], Field(description="Must be greater than or equal to 0")] = None,
        password_separators_gte: Annotated[Optional[StrictInt], Field(description="Must be greater than or equal to 0")] = None,
        password_other_gte: Annotated[Optional[StrictInt], Field(description="Must be greater than or equal to 0")] = None,
        password_entropy_gte: Annotated[Optional[StrictInt], Field(description="Must be greater than or equal to 0")] = None,
        password_plain: Annotated[Optional[StrictStr], Field(description="Must be URL encoded")] = None,
        credential_login: Annotated[Optional[StrictStr], Field(description="Search by credential login.")] = None,
        detected_malware: Annotated[Optional[StrictStr], Field(description="Search by credential detected malware. For example: agent_tesla, Lumma, VIDAR")] = None,
        girs: Annotated[Optional[StrictStr], Field(description="Filter results by custom GIRs (General Intelligence Requirements), my_girs or company_pirs. Using multiple values will return results based on the aggregated GIR list")] = None,
        var_from: Annotated[Optional[StrictInt], Field(description="UNIX timestamp(in milliseconds)")] = None,
        until: Annotated[Optional[StrictInt], Field(description="UNIX timestamp(in milliseconds)")] = None,
        last_updated_from: Annotated[Optional[StrictStr], Field(description="UNIX timestamp(in milliseconds) or period e.g. 24hours or 7days")] = None,
        last_updated_until: Annotated[Optional[StrictStr], Field(description="UNIX timestamp(in milliseconds) or period e.g. 24hours or 7days")] = None,
        size: Annotated[Optional[StrictInt], Field(description="Range is: [1, 1000]")] = None,
        cursor: Annotated[Optional[StrictStr], Field(description="Continue scrolling from cursor")] = 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,
    ) -> GetCredResponseStream:
        """Credential stream

        Returns list of Credentials matching filter criteria. The response contains “cursor_next” field, which should be provided to the next subsequent call to fetch potential next page of the results. Results are sorted by ascending order of the last_updated_ts field. Two indications of the end of the stream are possible: the result list is empty or its size is less than the requested items count.

        :param credential_set_name: Search by credential set name.
        :type credential_set_name: str
        :param credential_set_id: Search by credential set id.
        :type credential_set_id: str
        :param domain: Search by credential domain(detection domain).
        :type domain: str
        :param affiliation_group: Possible values: my_employees, my_customers, third_parties, vip_emails
        :type affiliation_group: str
        :param password_strength: Possible values: excellent, strong, medium, weak, poor, not_provided
        :type password_strength: str
        :param password_length_gte: Must be greater than or equal to 0
        :type password_length_gte: int
        :param password_lowercase_gte: Must be greater than or equal to 0
        :type password_lowercase_gte: int
        :param password_uppercase_gte: Must be greater than or equal to 0
        :type password_uppercase_gte: int
        :param password_numbers_gte: Must be greater than or equal to 0
        :type password_numbers_gte: int
        :param password_punctuation_gte: Must be greater than or equal to 0
        :type password_punctuation_gte: int
        :param password_symbols_gte: Must be greater than or equal to 0
        :type password_symbols_gte: int
        :param password_separators_gte: Must be greater than or equal to 0
        :type password_separators_gte: int
        :param password_other_gte: Must be greater than or equal to 0
        :type password_other_gte: int
        :param password_entropy_gte: Must be greater than or equal to 0
        :type password_entropy_gte: int
        :param password_plain: Must be URL encoded
        :type password_plain: str
        :param credential_login: Search by credential login.
        :type credential_login: str
        :param detected_malware: Search by credential detected malware. For example: agent_tesla, Lumma, VIDAR
        :type detected_malware: str
        :param girs: Filter results by custom GIRs (General Intelligence Requirements), my_girs or company_pirs. Using multiple values will return results based on the aggregated GIR list
        :type girs: str
        :param var_from: UNIX timestamp(in milliseconds)
        :type var_from: int
        :param until: UNIX timestamp(in milliseconds)
        :type until: int
        :param last_updated_from: UNIX timestamp(in milliseconds) or period e.g. 24hours or 7days
        :type last_updated_from: str
        :param last_updated_until: UNIX timestamp(in milliseconds) or period e.g. 24hours or 7days
        :type last_updated_until: str
        :param size: Range is: [1, 1000]
        :type size: int
        :param cursor: Continue scrolling from cursor
        :type cursor: 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_credentials_stream_serialize(
            credential_set_name=credential_set_name,
            credential_set_id=credential_set_id,
            domain=domain,
            affiliation_group=affiliation_group,
            password_strength=password_strength,
            password_length_gte=password_length_gte,
            password_lowercase_gte=password_lowercase_gte,
            password_uppercase_gte=password_uppercase_gte,
            password_numbers_gte=password_numbers_gte,
            password_punctuation_gte=password_punctuation_gte,
            password_symbols_gte=password_symbols_gte,
            password_separators_gte=password_separators_gte,
            password_other_gte=password_other_gte,
            password_entropy_gte=password_entropy_gte,
            password_plain=password_plain,
            credential_login=credential_login,
            detected_malware=detected_malware,
            girs=girs,
            var_from=var_from,
            until=until,
            last_updated_from=last_updated_from,
            last_updated_until=last_updated_until,
            size=size,
            cursor=cursor,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "GetCredResponseStream",
            '400': "BadRequest",
            '401': "Unauthorized",
            '403': "Forbidden",
            '404': "NotFound",
            '409': "Conflict",
            '500': "InternalServerError",
        }
        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_credentials_stream_with_http_info(
        self,
        credential_set_name: Annotated[Optional[StrictStr], Field(description="Search by credential set name.")] = None,
        credential_set_id: Annotated[Optional[StrictStr], Field(description="Search by credential set id.")] = None,
        domain: Annotated[Optional[StrictStr], Field(description="Search by credential domain(detection domain).")] = None,
        affiliation_group: Annotated[Optional[StrictStr], Field(description="Possible values: my_employees, my_customers, third_parties, vip_emails")] = None,
        password_strength: Annotated[Optional[StrictStr], Field(description="Possible values: excellent, strong, medium, weak, poor, not_provided")] = None,
        password_length_gte: Annotated[Optional[StrictInt], Field(description="Must be greater than or equal to 0")] = None,
        password_lowercase_gte: Annotated[Optional[StrictInt], Field(description="Must be greater than or equal to 0")] = None,
        password_uppercase_gte: Annotated[Optional[StrictInt], Field(description="Must be greater than or equal to 0")] = None,
        password_numbers_gte: Annotated[Optional[StrictInt], Field(description="Must be greater than or equal to 0")] = None,
        password_punctuation_gte: Annotated[Optional[StrictInt], Field(description="Must be greater than or equal to 0")] = None,
        password_symbols_gte: Annotated[Optional[StrictInt], Field(description="Must be greater than or equal to 0")] = None,
        password_separators_gte: Annotated[Optional[StrictInt], Field(description="Must be greater than or equal to 0")] = None,
        password_other_gte: Annotated[Optional[StrictInt], Field(description="Must be greater than or equal to 0")] = None,
        password_entropy_gte: Annotated[Optional[StrictInt], Field(description="Must be greater than or equal to 0")] = None,
        password_plain: Annotated[Optional[StrictStr], Field(description="Must be URL encoded")] = None,
        credential_login: Annotated[Optional[StrictStr], Field(description="Search by credential login.")] = None,
        detected_malware: Annotated[Optional[StrictStr], Field(description="Search by credential detected malware. For example: agent_tesla, Lumma, VIDAR")] = None,
        girs: Annotated[Optional[StrictStr], Field(description="Filter results by custom GIRs (General Intelligence Requirements), my_girs or company_pirs. Using multiple values will return results based on the aggregated GIR list")] = None,
        var_from: Annotated[Optional[StrictInt], Field(description="UNIX timestamp(in milliseconds)")] = None,
        until: Annotated[Optional[StrictInt], Field(description="UNIX timestamp(in milliseconds)")] = None,
        last_updated_from: Annotated[Optional[StrictStr], Field(description="UNIX timestamp(in milliseconds) or period e.g. 24hours or 7days")] = None,
        last_updated_until: Annotated[Optional[StrictStr], Field(description="UNIX timestamp(in milliseconds) or period e.g. 24hours or 7days")] = None,
        size: Annotated[Optional[StrictInt], Field(description="Range is: [1, 1000]")] = None,
        cursor: Annotated[Optional[StrictStr], Field(description="Continue scrolling from cursor")] = 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[GetCredResponseStream]:
        """Credential stream

        Returns list of Credentials matching filter criteria. The response contains “cursor_next” field, which should be provided to the next subsequent call to fetch potential next page of the results. Results are sorted by ascending order of the last_updated_ts field. Two indications of the end of the stream are possible: the result list is empty or its size is less than the requested items count.

        :param credential_set_name: Search by credential set name.
        :type credential_set_name: str
        :param credential_set_id: Search by credential set id.
        :type credential_set_id: str
        :param domain: Search by credential domain(detection domain).
        :type domain: str
        :param affiliation_group: Possible values: my_employees, my_customers, third_parties, vip_emails
        :type affiliation_group: str
        :param password_strength: Possible values: excellent, strong, medium, weak, poor, not_provided
        :type password_strength: str
        :param password_length_gte: Must be greater than or equal to 0
        :type password_length_gte: int
        :param password_lowercase_gte: Must be greater than or equal to 0
        :type password_lowercase_gte: int
        :param password_uppercase_gte: Must be greater than or equal to 0
        :type password_uppercase_gte: int
        :param password_numbers_gte: Must be greater than or equal to 0
        :type password_numbers_gte: int
        :param password_punctuation_gte: Must be greater than or equal to 0
        :type password_punctuation_gte: int
        :param password_symbols_gte: Must be greater than or equal to 0
        :type password_symbols_gte: int
        :param password_separators_gte: Must be greater than or equal to 0
        :type password_separators_gte: int
        :param password_other_gte: Must be greater than or equal to 0
        :type password_other_gte: int
        :param password_entropy_gte: Must be greater than or equal to 0
        :type password_entropy_gte: int
        :param password_plain: Must be URL encoded
        :type password_plain: str
        :param credential_login: Search by credential login.
        :type credential_login: str
        :param detected_malware: Search by credential detected malware. For example: agent_tesla, Lumma, VIDAR
        :type detected_malware: str
        :param girs: Filter results by custom GIRs (General Intelligence Requirements), my_girs or company_pirs. Using multiple values will return results based on the aggregated GIR list
        :type girs: str
        :param var_from: UNIX timestamp(in milliseconds)
        :type var_from: int
        :param until: UNIX timestamp(in milliseconds)
        :type until: int
        :param last_updated_from: UNIX timestamp(in milliseconds) or period e.g. 24hours or 7days
        :type last_updated_from: str
        :param last_updated_until: UNIX timestamp(in milliseconds) or period e.g. 24hours or 7days
        :type last_updated_until: str
        :param size: Range is: [1, 1000]
        :type size: int
        :param cursor: Continue scrolling from cursor
        :type cursor: 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_credentials_stream_serialize(
            credential_set_name=credential_set_name,
            credential_set_id=credential_set_id,
            domain=domain,
            affiliation_group=affiliation_group,
            password_strength=password_strength,
            password_length_gte=password_length_gte,
            password_lowercase_gte=password_lowercase_gte,
            password_uppercase_gte=password_uppercase_gte,
            password_numbers_gte=password_numbers_gte,
            password_punctuation_gte=password_punctuation_gte,
            password_symbols_gte=password_symbols_gte,
            password_separators_gte=password_separators_gte,
            password_other_gte=password_other_gte,
            password_entropy_gte=password_entropy_gte,
            password_plain=password_plain,
            credential_login=credential_login,
            detected_malware=detected_malware,
            girs=girs,
            var_from=var_from,
            until=until,
            last_updated_from=last_updated_from,
            last_updated_until=last_updated_until,
            size=size,
            cursor=cursor,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "GetCredResponseStream",
            '400': "BadRequest",
            '401': "Unauthorized",
            '403': "Forbidden",
            '404': "NotFound",
            '409': "Conflict",
            '500': "InternalServerError",
        }
        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_credentials_stream_without_preload_content(
        self,
        credential_set_name: Annotated[Optional[StrictStr], Field(description="Search by credential set name.")] = None,
        credential_set_id: Annotated[Optional[StrictStr], Field(description="Search by credential set id.")] = None,
        domain: Annotated[Optional[StrictStr], Field(description="Search by credential domain(detection domain).")] = None,
        affiliation_group: Annotated[Optional[StrictStr], Field(description="Possible values: my_employees, my_customers, third_parties, vip_emails")] = None,
        password_strength: Annotated[Optional[StrictStr], Field(description="Possible values: excellent, strong, medium, weak, poor, not_provided")] = None,
        password_length_gte: Annotated[Optional[StrictInt], Field(description="Must be greater than or equal to 0")] = None,
        password_lowercase_gte: Annotated[Optional[StrictInt], Field(description="Must be greater than or equal to 0")] = None,
        password_uppercase_gte: Annotated[Optional[StrictInt], Field(description="Must be greater than or equal to 0")] = None,
        password_numbers_gte: Annotated[Optional[StrictInt], Field(description="Must be greater than or equal to 0")] = None,
        password_punctuation_gte: Annotated[Optional[StrictInt], Field(description="Must be greater than or equal to 0")] = None,
        password_symbols_gte: Annotated[Optional[StrictInt], Field(description="Must be greater than or equal to 0")] = None,
        password_separators_gte: Annotated[Optional[StrictInt], Field(description="Must be greater than or equal to 0")] = None,
        password_other_gte: Annotated[Optional[StrictInt], Field(description="Must be greater than or equal to 0")] = None,
        password_entropy_gte: Annotated[Optional[StrictInt], Field(description="Must be greater than or equal to 0")] = None,
        password_plain: Annotated[Optional[StrictStr], Field(description="Must be URL encoded")] = None,
        credential_login: Annotated[Optional[StrictStr], Field(description="Search by credential login.")] = None,
        detected_malware: Annotated[Optional[StrictStr], Field(description="Search by credential detected malware. For example: agent_tesla, Lumma, VIDAR")] = None,
        girs: Annotated[Optional[StrictStr], Field(description="Filter results by custom GIRs (General Intelligence Requirements), my_girs or company_pirs. Using multiple values will return results based on the aggregated GIR list")] = None,
        var_from: Annotated[Optional[StrictInt], Field(description="UNIX timestamp(in milliseconds)")] = None,
        until: Annotated[Optional[StrictInt], Field(description="UNIX timestamp(in milliseconds)")] = None,
        last_updated_from: Annotated[Optional[StrictStr], Field(description="UNIX timestamp(in milliseconds) or period e.g. 24hours or 7days")] = None,
        last_updated_until: Annotated[Optional[StrictStr], Field(description="UNIX timestamp(in milliseconds) or period e.g. 24hours or 7days")] = None,
        size: Annotated[Optional[StrictInt], Field(description="Range is: [1, 1000]")] = None,
        cursor: Annotated[Optional[StrictStr], Field(description="Continue scrolling from cursor")] = 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:
        """Credential stream

        Returns list of Credentials matching filter criteria. The response contains “cursor_next” field, which should be provided to the next subsequent call to fetch potential next page of the results. Results are sorted by ascending order of the last_updated_ts field. Two indications of the end of the stream are possible: the result list is empty or its size is less than the requested items count.

        :param credential_set_name: Search by credential set name.
        :type credential_set_name: str
        :param credential_set_id: Search by credential set id.
        :type credential_set_id: str
        :param domain: Search by credential domain(detection domain).
        :type domain: str
        :param affiliation_group: Possible values: my_employees, my_customers, third_parties, vip_emails
        :type affiliation_group: str
        :param password_strength: Possible values: excellent, strong, medium, weak, poor, not_provided
        :type password_strength: str
        :param password_length_gte: Must be greater than or equal to 0
        :type password_length_gte: int
        :param password_lowercase_gte: Must be greater than or equal to 0
        :type password_lowercase_gte: int
        :param password_uppercase_gte: Must be greater than or equal to 0
        :type password_uppercase_gte: int
        :param password_numbers_gte: Must be greater than or equal to 0
        :type password_numbers_gte: int
        :param password_punctuation_gte: Must be greater than or equal to 0
        :type password_punctuation_gte: int
        :param password_symbols_gte: Must be greater than or equal to 0
        :type password_symbols_gte: int
        :param password_separators_gte: Must be greater than or equal to 0
        :type password_separators_gte: int
        :param password_other_gte: Must be greater than or equal to 0
        :type password_other_gte: int
        :param password_entropy_gte: Must be greater than or equal to 0
        :type password_entropy_gte: int
        :param password_plain: Must be URL encoded
        :type password_plain: str
        :param credential_login: Search by credential login.
        :type credential_login: str
        :param detected_malware: Search by credential detected malware. For example: agent_tesla, Lumma, VIDAR
        :type detected_malware: str
        :param girs: Filter results by custom GIRs (General Intelligence Requirements), my_girs or company_pirs. Using multiple values will return results based on the aggregated GIR list
        :type girs: str
        :param var_from: UNIX timestamp(in milliseconds)
        :type var_from: int
        :param until: UNIX timestamp(in milliseconds)
        :type until: int
        :param last_updated_from: UNIX timestamp(in milliseconds) or period e.g. 24hours or 7days
        :type last_updated_from: str
        :param last_updated_until: UNIX timestamp(in milliseconds) or period e.g. 24hours or 7days
        :type last_updated_until: str
        :param size: Range is: [1, 1000]
        :type size: int
        :param cursor: Continue scrolling from cursor
        :type cursor: 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_credentials_stream_serialize(
            credential_set_name=credential_set_name,
            credential_set_id=credential_set_id,
            domain=domain,
            affiliation_group=affiliation_group,
            password_strength=password_strength,
            password_length_gte=password_length_gte,
            password_lowercase_gte=password_lowercase_gte,
            password_uppercase_gte=password_uppercase_gte,
            password_numbers_gte=password_numbers_gte,
            password_punctuation_gte=password_punctuation_gte,
            password_symbols_gte=password_symbols_gte,
            password_separators_gte=password_separators_gte,
            password_other_gte=password_other_gte,
            password_entropy_gte=password_entropy_gte,
            password_plain=password_plain,
            credential_login=credential_login,
            detected_malware=detected_malware,
            girs=girs,
            var_from=var_from,
            until=until,
            last_updated_from=last_updated_from,
            last_updated_until=last_updated_until,
            size=size,
            cursor=cursor,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "GetCredResponseStream",
            '400': "BadRequest",
            '401': "Unauthorized",
            '403': "Forbidden",
            '404': "NotFound",
            '409': "Conflict",
            '500': "InternalServerError",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_credentials_stream_serialize(
        self,
        credential_set_name,
        credential_set_id,
        domain,
        affiliation_group,
        password_strength,
        password_length_gte,
        password_lowercase_gte,
        password_uppercase_gte,
        password_numbers_gte,
        password_punctuation_gte,
        password_symbols_gte,
        password_separators_gte,
        password_other_gte,
        password_entropy_gte,
        password_plain,
        credential_login,
        detected_malware,
        girs,
        var_from,
        until,
        last_updated_from,
        last_updated_until,
        size,
        cursor,
        _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
        if credential_set_name is not None:
            
            _query_params.append(('credential_set_name', credential_set_name))
            
        if credential_set_id is not None:
            
            _query_params.append(('credential_set_id', credential_set_id))
            
        if domain is not None:
            
            _query_params.append(('domain', domain))
            
        if affiliation_group is not None:
            
            _query_params.append(('affiliation_group', affiliation_group))
            
        if password_strength is not None:
            
            _query_params.append(('password_strength', password_strength))
            
        if password_length_gte is not None:
            
            _query_params.append(('password_length_gte', password_length_gte))
            
        if password_lowercase_gte is not None:
            
            _query_params.append(('password_lowercase_gte', password_lowercase_gte))
            
        if password_uppercase_gte is not None:
            
            _query_params.append(('password_uppercase_gte', password_uppercase_gte))
            
        if password_numbers_gte is not None:
            
            _query_params.append(('password_numbers_gte', password_numbers_gte))
            
        if password_punctuation_gte is not None:
            
            _query_params.append(('password_punctuation_gte', password_punctuation_gte))
            
        if password_symbols_gte is not None:
            
            _query_params.append(('password_symbols_gte', password_symbols_gte))
            
        if password_separators_gte is not None:
            
            _query_params.append(('password_separators_gte', password_separators_gte))
            
        if password_other_gte is not None:
            
            _query_params.append(('password_other_gte', password_other_gte))
            
        if password_entropy_gte is not None:
            
            _query_params.append(('password_entropy_gte', password_entropy_gte))
            
        if password_plain is not None:
            
            _query_params.append(('password_plain', password_plain))
            
        if credential_login is not None:
            
            _query_params.append(('credential_login', credential_login))
            
        if detected_malware is not None:
            
            _query_params.append(('detected_malware', detected_malware))
            
        if girs is not None:
            
            _query_params.append(('girs', girs))
            
        if var_from is not None:
            
            _query_params.append(('from', var_from))
            
        if until is not None:
            
            _query_params.append(('until', until))
            
        if last_updated_from is not None:
            
            _query_params.append(('last_updated_from', last_updated_from))
            
        if last_updated_until is not None:
            
            _query_params.append(('last_updated_until', last_updated_until))
            
        if size is not None:
            
            _query_params.append(('size', size))
            
        if cursor is not None:
            
            _query_params.append(('cursor', cursor))
            
        # 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] = [
            'basicAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/integrations/creds/v1/credentials/stream',
            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
        )


