"""
    Umweltbundesamt: Meeresumweltdatenbank (MUDAB)

    Meeres-Monitoringdaten von Küstenbundesländern und Forschungseinrichtungen   # noqa: E501

    The version of the OpenAPI document: 1.0.0
    Generated by: https://openapi-generator.tech
"""


import re  # noqa: F401
import sys  # noqa: F401

from deutschland.mudab.api_client import ApiClient, Endpoint as _Endpoint
from deutschland.mudab.model_utils import (  # noqa: F401
    check_allowed_values,
    check_validations,
    date,
    datetime,
    file_type,
    none_type,
    validate_and_convert_types,
)
from deutschland.mudab.model.filter_request import FilterRequest
from deutschland.mudab.model.inline_response200 import InlineResponse200
from deutschland.mudab.model.inline_response2001 import InlineResponse2001
from deutschland.mudab.model.inline_response2002 import InlineResponse2002
from deutschland.mudab.model.inline_response2003 import InlineResponse2003
from deutschland.mudab.model.inline_response2004 import InlineResponse2004
from deutschland.mudab.model.inline_response2005 import InlineResponse2005
from deutschland.mudab.model.inline_response2006 import InlineResponse2006
from deutschland.mudab.model.inline_response2007 import InlineResponse2007
from deutschland.mudab.model.inline_response2008 import InlineResponse2008


class DefaultApi(object):
    """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):
        if api_client is None:
            api_client = ApiClient()
        self.api_client = api_client
        self.list_mess_stationen_endpoint = _Endpoint(
            settings={
                "response_type": (InlineResponse2001,),
                "auth": [],
                "endpoint_path": "/STATION_SMALL",
                "operation_id": "list_mess_stationen",
                "http_method": "POST",
                "servers": None,
            },
            params_map={
                "all": [
                    "filter_request",
                ],
                "required": [],
                "nullable": [],
                "enum": [],
                "validation": [],
            },
            root_map={
                "validations": {},
                "allowed_values": {},
                "openapi_types": {
                    "filter_request": (FilterRequest,),
                },
                "attribute_map": {},
                "location_map": {
                    "filter_request": "body",
                },
                "collection_format_map": {},
            },
            headers_map={
                "accept": ["application/json"],
                "content_type": ["application/json"],
            },
            api_client=api_client,
        )
        self.list_parameter_endpoint = _Endpoint(
            settings={
                "response_type": (InlineResponse2002,),
                "auth": [],
                "endpoint_path": "/MV_PARAMETER",
                "operation_id": "list_parameter",
                "http_method": "POST",
                "servers": None,
            },
            params_map={
                "all": [
                    "filter_request",
                ],
                "required": [],
                "nullable": [],
                "enum": [],
                "validation": [],
            },
            root_map={
                "validations": {},
                "allowed_values": {},
                "openapi_types": {
                    "filter_request": (FilterRequest,),
                },
                "attribute_map": {},
                "location_map": {
                    "filter_request": "body",
                },
                "collection_format_map": {},
            },
            headers_map={
                "accept": ["application/json"],
                "content_type": ["application/json"],
            },
            api_client=api_client,
        )
        self.list_parameter_values_endpoint = _Endpoint(
            settings={
                "response_type": (InlineResponse2003,),
                "auth": [],
                "endpoint_path": "/MV_STATION_MSMNT",
                "operation_id": "list_parameter_values",
                "http_method": "POST",
                "servers": None,
            },
            params_map={
                "all": [
                    "filter_request",
                ],
                "required": [],
                "nullable": [],
                "enum": [],
                "validation": [],
            },
            root_map={
                "validations": {},
                "allowed_values": {},
                "openapi_types": {
                    "filter_request": (FilterRequest,),
                },
                "attribute_map": {},
                "location_map": {
                    "filter_request": "body",
                },
                "collection_format_map": {},
            },
            headers_map={
                "accept": ["application/json"],
                "content_type": ["application/json"],
            },
            api_client=api_client,
        )
        self.list_parameters_biologie_endpoint = _Endpoint(
            settings={
                "response_type": (InlineResponse2004,),
                "auth": [],
                "endpoint_path": "/MV_PARAMETER_BIOLOGIE",
                "operation_id": "list_parameters_biologie",
                "http_method": "POST",
                "servers": None,
            },
            params_map={
                "all": [
                    "filter_request",
                ],
                "required": [],
                "nullable": [],
                "enum": [],
                "validation": [],
            },
            root_map={
                "validations": {},
                "allowed_values": {},
                "openapi_types": {
                    "filter_request": (FilterRequest,),
                },
                "attribute_map": {},
                "location_map": {
                    "filter_request": "body",
                },
                "collection_format_map": {},
            },
            headers_map={
                "accept": ["application/json"],
                "content_type": ["application/json"],
            },
            api_client=api_client,
        )
        self.list_parameters_biota_endpoint = _Endpoint(
            settings={
                "response_type": (InlineResponse2005,),
                "auth": [],
                "endpoint_path": "/MV_PARAMETER_BIOTA",
                "operation_id": "list_parameters_biota",
                "http_method": "POST",
                "servers": None,
            },
            params_map={
                "all": [
                    "filter_request",
                ],
                "required": [],
                "nullable": [],
                "enum": [],
                "validation": [],
            },
            root_map={
                "validations": {},
                "allowed_values": {},
                "openapi_types": {
                    "filter_request": (FilterRequest,),
                },
                "attribute_map": {},
                "location_map": {
                    "filter_request": "body",
                },
                "collection_format_map": {},
            },
            headers_map={
                "accept": ["application/json"],
                "content_type": ["application/json"],
            },
            api_client=api_client,
        )
        self.list_parameters_sediment_endpoint = _Endpoint(
            settings={
                "response_type": (InlineResponse2007,),
                "auth": [],
                "endpoint_path": "/MV_PARAMETER_SEDIMENT",
                "operation_id": "list_parameters_sediment",
                "http_method": "POST",
                "servers": None,
            },
            params_map={
                "all": [
                    "filter_request",
                ],
                "required": [],
                "nullable": [],
                "enum": [],
                "validation": [],
            },
            root_map={
                "validations": {},
                "allowed_values": {},
                "openapi_types": {
                    "filter_request": (FilterRequest,),
                },
                "attribute_map": {},
                "location_map": {
                    "filter_request": "body",
                },
                "collection_format_map": {},
            },
            headers_map={
                "accept": ["application/json"],
                "content_type": ["application/json"],
            },
            api_client=api_client,
        )
        self.list_parameters_wasser_endpoint = _Endpoint(
            settings={
                "response_type": (InlineResponse2006,),
                "auth": [],
                "endpoint_path": "/MV_PARAMETER_WASSER",
                "operation_id": "list_parameters_wasser",
                "http_method": "POST",
                "servers": None,
            },
            params_map={
                "all": [
                    "filter_request",
                ],
                "required": [],
                "nullable": [],
                "enum": [],
                "validation": [],
            },
            root_map={
                "validations": {},
                "allowed_values": {},
                "openapi_types": {
                    "filter_request": (FilterRequest,),
                },
                "attribute_map": {},
                "location_map": {
                    "filter_request": "body",
                },
                "collection_format_map": {},
            },
            headers_map={
                "accept": ["application/json"],
                "content_type": ["application/json"],
            },
            api_client=api_client,
        )
        self.list_plc_stations_endpoint = _Endpoint(
            settings={
                "response_type": (InlineResponse2008,),
                "auth": [],
                "endpoint_path": "/V_PLC_STATION",
                "operation_id": "list_plc_stations",
                "http_method": "POST",
                "servers": None,
            },
            params_map={
                "all": [
                    "filter_request",
                ],
                "required": [],
                "nullable": [],
                "enum": [],
                "validation": [],
            },
            root_map={
                "validations": {},
                "allowed_values": {},
                "openapi_types": {
                    "filter_request": (FilterRequest,),
                },
                "attribute_map": {},
                "location_map": {
                    "filter_request": "body",
                },
                "collection_format_map": {},
            },
            headers_map={
                "accept": ["application/json"],
                "content_type": ["application/json"],
            },
            api_client=api_client,
        )
        self.list_projekt_stationen_endpoint = _Endpoint(
            settings={
                "response_type": (InlineResponse200,),
                "auth": [],
                "endpoint_path": "/PROJECTSTATION_SMALL",
                "operation_id": "list_projekt_stationen",
                "http_method": "POST",
                "servers": None,
            },
            params_map={
                "all": [
                    "filter_request",
                ],
                "required": [],
                "nullable": [],
                "enum": [],
                "validation": [],
            },
            root_map={
                "validations": {},
                "allowed_values": {},
                "openapi_types": {
                    "filter_request": (FilterRequest,),
                },
                "attribute_map": {},
                "location_map": {
                    "filter_request": "body",
                },
                "collection_format_map": {},
            },
            headers_map={
                "accept": ["application/json"],
                "content_type": ["application/json"],
            },
            api_client=api_client,
        )

    def list_mess_stationen(self, **kwargs):
        """Liste aller Messstationen  # noqa: E501

        Gibt eine filterbare Liste aller Messtationen in der Datenbank zurück. Filterbare Attribute sind die Felder die aus dem Messstation Schema kommen.   # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.list_mess_stationen(async_req=True)
        >>> result = thread.get()


        Keyword Args:
            filter_request (FilterRequest): [optional]
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/float/tuple): 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.
                Default is None.
            _check_input_type (bool): specifies if type checking
                should be done one the data sent to the server.
                Default is True.
            _check_return_type (bool): specifies if type checking
                should be done one the data received from the server.
                Default is True.
            _host_index (int/None): specifies the index of the server
                that we want to use.
                Default is read from the configuration.
            async_req (bool): execute request asynchronously

        Returns:
            InlineResponse2001
                If the method is called asynchronously, returns the request
                thread.
        """
        kwargs["async_req"] = kwargs.get("async_req", False)
        kwargs["_return_http_data_only"] = kwargs.get("_return_http_data_only", True)
        kwargs["_preload_content"] = kwargs.get("_preload_content", True)
        kwargs["_request_timeout"] = kwargs.get("_request_timeout", None)
        kwargs["_check_input_type"] = kwargs.get("_check_input_type", True)
        kwargs["_check_return_type"] = kwargs.get("_check_return_type", True)
        kwargs["_host_index"] = kwargs.get("_host_index")
        return self.list_mess_stationen_endpoint.call_with_http_info(**kwargs)

    def list_parameter(self, **kwargs):
        """Liste aller Parameter  # noqa: E501

        Gibt eine filterbare Liste aller Parameter in der Datenbank zurück. Filterbare Attribute sind die Felder die aus dem Parameter Schema kommen.   # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.list_parameter(async_req=True)
        >>> result = thread.get()


        Keyword Args:
            filter_request (FilterRequest): [optional]
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/float/tuple): 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.
                Default is None.
            _check_input_type (bool): specifies if type checking
                should be done one the data sent to the server.
                Default is True.
            _check_return_type (bool): specifies if type checking
                should be done one the data received from the server.
                Default is True.
            _host_index (int/None): specifies the index of the server
                that we want to use.
                Default is read from the configuration.
            async_req (bool): execute request asynchronously

        Returns:
            InlineResponse2002
                If the method is called asynchronously, returns the request
                thread.
        """
        kwargs["async_req"] = kwargs.get("async_req", False)
        kwargs["_return_http_data_only"] = kwargs.get("_return_http_data_only", True)
        kwargs["_preload_content"] = kwargs.get("_preload_content", True)
        kwargs["_request_timeout"] = kwargs.get("_request_timeout", None)
        kwargs["_check_input_type"] = kwargs.get("_check_input_type", True)
        kwargs["_check_return_type"] = kwargs.get("_check_return_type", True)
        kwargs["_host_index"] = kwargs.get("_host_index")
        return self.list_parameter_endpoint.call_with_http_info(**kwargs)

    def list_parameter_values(self, **kwargs):
        """Liste aller Messwerte  # noqa: E501

        Gibt eine filterbare Liste aller Messwerte in der Datenbank zurück. Filterbare Attribute sind die Felder die aus dem ParameterValue Schema kommen.   # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.list_parameter_values(async_req=True)
        >>> result = thread.get()


        Keyword Args:
            filter_request (FilterRequest): [optional]
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/float/tuple): 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.
                Default is None.
            _check_input_type (bool): specifies if type checking
                should be done one the data sent to the server.
                Default is True.
            _check_return_type (bool): specifies if type checking
                should be done one the data received from the server.
                Default is True.
            _host_index (int/None): specifies the index of the server
                that we want to use.
                Default is read from the configuration.
            async_req (bool): execute request asynchronously

        Returns:
            InlineResponse2003
                If the method is called asynchronously, returns the request
                thread.
        """
        kwargs["async_req"] = kwargs.get("async_req", False)
        kwargs["_return_http_data_only"] = kwargs.get("_return_http_data_only", True)
        kwargs["_preload_content"] = kwargs.get("_preload_content", True)
        kwargs["_request_timeout"] = kwargs.get("_request_timeout", None)
        kwargs["_check_input_type"] = kwargs.get("_check_input_type", True)
        kwargs["_check_return_type"] = kwargs.get("_check_return_type", True)
        kwargs["_host_index"] = kwargs.get("_host_index")
        return self.list_parameter_values_endpoint.call_with_http_info(**kwargs)

    def list_parameters_biologie(self, **kwargs):
        """Liste aller Parameter im Biologie Kompartiment  # noqa: E501

        Gibt eine filterbare Liste aller Parameter in der Datenbank aus dem Kompartiment Biologie zurück. Filterbare Attribute sind die Felder die aus dem Parameter Schema kommen.   # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.list_parameters_biologie(async_req=True)
        >>> result = thread.get()


        Keyword Args:
            filter_request (FilterRequest): [optional]
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/float/tuple): 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.
                Default is None.
            _check_input_type (bool): specifies if type checking
                should be done one the data sent to the server.
                Default is True.
            _check_return_type (bool): specifies if type checking
                should be done one the data received from the server.
                Default is True.
            _host_index (int/None): specifies the index of the server
                that we want to use.
                Default is read from the configuration.
            async_req (bool): execute request asynchronously

        Returns:
            InlineResponse2004
                If the method is called asynchronously, returns the request
                thread.
        """
        kwargs["async_req"] = kwargs.get("async_req", False)
        kwargs["_return_http_data_only"] = kwargs.get("_return_http_data_only", True)
        kwargs["_preload_content"] = kwargs.get("_preload_content", True)
        kwargs["_request_timeout"] = kwargs.get("_request_timeout", None)
        kwargs["_check_input_type"] = kwargs.get("_check_input_type", True)
        kwargs["_check_return_type"] = kwargs.get("_check_return_type", True)
        kwargs["_host_index"] = kwargs.get("_host_index")
        return self.list_parameters_biologie_endpoint.call_with_http_info(**kwargs)

    def list_parameters_biota(self, **kwargs):
        """Liste aller Parameter im Biota Kompartiment  # noqa: E501

        Gibt eine filterbare Liste aller Parameter in der Datenbank aus dem Kompartiment Biota zurück. Filterbare Attribute sind die Felder die aus dem Parameter Schema kommen.   # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.list_parameters_biota(async_req=True)
        >>> result = thread.get()


        Keyword Args:
            filter_request (FilterRequest): [optional]
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/float/tuple): 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.
                Default is None.
            _check_input_type (bool): specifies if type checking
                should be done one the data sent to the server.
                Default is True.
            _check_return_type (bool): specifies if type checking
                should be done one the data received from the server.
                Default is True.
            _host_index (int/None): specifies the index of the server
                that we want to use.
                Default is read from the configuration.
            async_req (bool): execute request asynchronously

        Returns:
            InlineResponse2005
                If the method is called asynchronously, returns the request
                thread.
        """
        kwargs["async_req"] = kwargs.get("async_req", False)
        kwargs["_return_http_data_only"] = kwargs.get("_return_http_data_only", True)
        kwargs["_preload_content"] = kwargs.get("_preload_content", True)
        kwargs["_request_timeout"] = kwargs.get("_request_timeout", None)
        kwargs["_check_input_type"] = kwargs.get("_check_input_type", True)
        kwargs["_check_return_type"] = kwargs.get("_check_return_type", True)
        kwargs["_host_index"] = kwargs.get("_host_index")
        return self.list_parameters_biota_endpoint.call_with_http_info(**kwargs)

    def list_parameters_sediment(self, **kwargs):
        """Liste aller Parameter im Sediment Kompartiment  # noqa: E501

        Gibt eine filterbare Liste aller Parameter in der Datenbank aus dem Kompartiment Sediment zurück. Filterbare Attribute sind die Felder die aus dem Parameter Schema kommen.   # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.list_parameters_sediment(async_req=True)
        >>> result = thread.get()


        Keyword Args:
            filter_request (FilterRequest): [optional]
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/float/tuple): 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.
                Default is None.
            _check_input_type (bool): specifies if type checking
                should be done one the data sent to the server.
                Default is True.
            _check_return_type (bool): specifies if type checking
                should be done one the data received from the server.
                Default is True.
            _host_index (int/None): specifies the index of the server
                that we want to use.
                Default is read from the configuration.
            async_req (bool): execute request asynchronously

        Returns:
            InlineResponse2007
                If the method is called asynchronously, returns the request
                thread.
        """
        kwargs["async_req"] = kwargs.get("async_req", False)
        kwargs["_return_http_data_only"] = kwargs.get("_return_http_data_only", True)
        kwargs["_preload_content"] = kwargs.get("_preload_content", True)
        kwargs["_request_timeout"] = kwargs.get("_request_timeout", None)
        kwargs["_check_input_type"] = kwargs.get("_check_input_type", True)
        kwargs["_check_return_type"] = kwargs.get("_check_return_type", True)
        kwargs["_host_index"] = kwargs.get("_host_index")
        return self.list_parameters_sediment_endpoint.call_with_http_info(**kwargs)

    def list_parameters_wasser(self, **kwargs):
        """Liste aller Parameter im Wasser Kompartiment  # noqa: E501

        Gibt eine filterbare Liste aller Parameter in der Datenbank aus dem Kompartiment Wasser zurück. Filterbare Attribute sind die Felder die aus dem Parameter Schema kommen.   # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.list_parameters_wasser(async_req=True)
        >>> result = thread.get()


        Keyword Args:
            filter_request (FilterRequest): [optional]
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/float/tuple): 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.
                Default is None.
            _check_input_type (bool): specifies if type checking
                should be done one the data sent to the server.
                Default is True.
            _check_return_type (bool): specifies if type checking
                should be done one the data received from the server.
                Default is True.
            _host_index (int/None): specifies the index of the server
                that we want to use.
                Default is read from the configuration.
            async_req (bool): execute request asynchronously

        Returns:
            InlineResponse2006
                If the method is called asynchronously, returns the request
                thread.
        """
        kwargs["async_req"] = kwargs.get("async_req", False)
        kwargs["_return_http_data_only"] = kwargs.get("_return_http_data_only", True)
        kwargs["_preload_content"] = kwargs.get("_preload_content", True)
        kwargs["_request_timeout"] = kwargs.get("_request_timeout", None)
        kwargs["_check_input_type"] = kwargs.get("_check_input_type", True)
        kwargs["_check_return_type"] = kwargs.get("_check_return_type", True)
        kwargs["_host_index"] = kwargs.get("_host_index")
        return self.list_parameters_wasser_endpoint.call_with_http_info(**kwargs)

    def list_plc_stations(self, **kwargs):
        """Liste aller HELCOM PLC Stationen  # noqa: E501

        Gibt eine filterbare Liste aller HELCOM PLC Stationen in der Datenbank zurück. Filterbare Attribute sind die Felder die aus dem HelcomPLCStation Schema kommen.   # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.list_plc_stations(async_req=True)
        >>> result = thread.get()


        Keyword Args:
            filter_request (FilterRequest): [optional]
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/float/tuple): 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.
                Default is None.
            _check_input_type (bool): specifies if type checking
                should be done one the data sent to the server.
                Default is True.
            _check_return_type (bool): specifies if type checking
                should be done one the data received from the server.
                Default is True.
            _host_index (int/None): specifies the index of the server
                that we want to use.
                Default is read from the configuration.
            async_req (bool): execute request asynchronously

        Returns:
            InlineResponse2008
                If the method is called asynchronously, returns the request
                thread.
        """
        kwargs["async_req"] = kwargs.get("async_req", False)
        kwargs["_return_http_data_only"] = kwargs.get("_return_http_data_only", True)
        kwargs["_preload_content"] = kwargs.get("_preload_content", True)
        kwargs["_request_timeout"] = kwargs.get("_request_timeout", None)
        kwargs["_check_input_type"] = kwargs.get("_check_input_type", True)
        kwargs["_check_return_type"] = kwargs.get("_check_return_type", True)
        kwargs["_host_index"] = kwargs.get("_host_index")
        return self.list_plc_stations_endpoint.call_with_http_info(**kwargs)

    def list_projekt_stationen(self, **kwargs):
        """Liste aller Projekt Stationen  # noqa: E501

        Gibt eine filterbare Liste aller Projektstation in der Datenbank zurück. Filterbare Attribute sind die Felder die aus dem ProjectStation Schema kommen.   # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.list_projekt_stationen(async_req=True)
        >>> result = thread.get()


        Keyword Args:
            filter_request (FilterRequest): [optional]
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/float/tuple): 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.
                Default is None.
            _check_input_type (bool): specifies if type checking
                should be done one the data sent to the server.
                Default is True.
            _check_return_type (bool): specifies if type checking
                should be done one the data received from the server.
                Default is True.
            _host_index (int/None): specifies the index of the server
                that we want to use.
                Default is read from the configuration.
            async_req (bool): execute request asynchronously

        Returns:
            InlineResponse200
                If the method is called asynchronously, returns the request
                thread.
        """
        kwargs["async_req"] = kwargs.get("async_req", False)
        kwargs["_return_http_data_only"] = kwargs.get("_return_http_data_only", True)
        kwargs["_preload_content"] = kwargs.get("_preload_content", True)
        kwargs["_request_timeout"] = kwargs.get("_request_timeout", None)
        kwargs["_check_input_type"] = kwargs.get("_check_input_type", True)
        kwargs["_check_return_type"] = kwargs.get("_check_return_type", True)
        kwargs["_host_index"] = kwargs.get("_host_index")
        return self.list_projekt_stationen_endpoint.call_with_http_info(**kwargs)
