def __init__(self, api_client=None): if api_client is None: api_client = ApiClient() self.api_client = api_client def __date_time_difference(self, **kwargs): """DateTime - DateTime difference # noqa: E501 Calculate the difference between two dates # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.date_time_difference(async_req=True) >>> result = thread.get() Keyword Args: date_time_difference (InputDateTimeDifference): [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 (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: OutputDateDifference 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.call_with_http_info(**kwargs) self.date_time_difference = Endpoint( settings={ 'response_type': (OutputDateDifference, ), 'auth': ['apiKeyHeader'], 'endpoint_path': '/DateTimeDifference', 'operation_id': 'date_time_difference', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'date_time_difference', ], 'required': [], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'date_time_difference': (InputDateTimeDifference, ), }, 'attribute_map': {}, 'location_map': { 'date_time_difference': 'body', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': ['application/json'] }, api_client=api_client, callable=__date_time_difference) def __date_time_info(self, **kwargs): """DateTime - Get date and time information # noqa: E501 Retrieve useful date and time information, such as day of year, total seconds and ticks # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.date_time_info(async_req=True) >>> result = thread.get() Keyword Args: date_time_info (InputDateTimeInfo): [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 (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: OutputDateInfo 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.call_with_http_info(**kwargs) self.date_time_info = Endpoint(settings={ 'response_type': (OutputDateInfo, ), 'auth': ['apiKeyHeader'], 'endpoint_path': '/DateTimeInfo', 'operation_id': 'date_time_info', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'date_time_info', ], 'required': [], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'date_time_info': (InputDateTimeInfo, ), }, 'attribute_map': {}, 'location_map': { 'date_time_info': 'body', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': ['application/json'] }, api_client=api_client, callable=__date_time_info) def __format_date_time(self, **kwargs): """DateTime - Format date and time # noqa: E501 Create a date/time string in a specific format # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.format_date_time(async_req=True) >>> result = thread.get() Keyword Args: date_time_format (InputDateTimeFormat): [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 (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: OutputString 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.call_with_http_info(**kwargs) self.format_date_time = Endpoint(settings={ 'response_type': (OutputString, ), 'auth': ['apiKeyHeader'], 'endpoint_path': '/FormatDateTime', 'operation_id': 'format_date_time', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'date_time_format', ], 'required': [], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'date_time_format': (InputDateTimeFormat, ), }, 'attribute_map': {}, 'location_map': { 'date_time_format': 'body', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': ['application/json'] }, api_client=api_client, callable=__format_date_time) def __world_time(self, **kwargs): """DateTime - Get world time # noqa: E501 Convert date and time from one time zone to another # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.world_time(async_req=True) >>> result = thread.get() Keyword Args: date_time_conversion (InputDateTimeConversion): [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 (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: OutputString 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.call_with_http_info(**kwargs) self.world_time = Endpoint(settings={ 'response_type': (OutputString, ), 'auth': ['apiKeyHeader'], 'endpoint_path': '/WorldTime', 'operation_id': 'world_time', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'date_time_conversion', ], 'required': [], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'date_time_conversion': (InputDateTimeConversion, ), }, 'attribute_map': {}, 'location_map': { 'date_time_conversion': 'body', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': ['application/json'] }, api_client=api_client, callable=__world_time)
def __init__(self, api_client=None): if api_client is None: api_client = ApiClient() self.api_client = api_client def __get_gewijzigde_personen(self, **kwargs): """Raadpleeg personen met gewijzigde gegevens # noqa: E501 Vraag een lijst op met burgerservicenummers van personen met gewijzigde gegevens. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_gewijzigde_personen(async_req=True) >>> result = thread.get() Keyword Args: vanaf (date): Alleen personen waarbij gegevens zijn gewijzigd op of na deze datum worden geleverd.. [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 (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: GewijzigdePersonenHalCollectie 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.call_with_http_info(**kwargs) self.get_gewijzigde_personen = Endpoint( settings={ 'response_type': (GewijzigdePersonenHalCollectie, ), 'auth': [], 'endpoint_path': '/wijzigingen', 'operation_id': 'get_gewijzigde_personen', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'vanaf', ], 'required': [], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'vanaf': (date, ), }, 'attribute_map': { 'vanaf': 'vanaf', }, 'location_map': { 'vanaf': 'query', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/hal+json', 'application/problem+json'], 'content_type': [], }, api_client=api_client, callable=__get_gewijzigde_personen)
def __init__(self, api_client=None): if api_client is None: api_client = ApiClient() self.api_client = api_client def __convert_currency( self, **kwargs ): """Currency - Convert currency # noqa: E501 Calculate monetary value in a different currency # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.convert_currency(async_req=True) >>> result = thread.get() Keyword Args: currency_conversion (InputCurrencyConversion): [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 (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: OutputNumber 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.call_with_http_info(**kwargs) self.convert_currency = Endpoint( settings={ 'response_type': (OutputNumber,), 'auth': [ 'apiKeyHeader' ], 'endpoint_path': '/ConvertCurrency', 'operation_id': 'convert_currency', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'currency_conversion', ], 'required': [], 'nullable': [ ], 'enum': [ ], 'validation': [ ] }, root_map={ 'validations': { }, 'allowed_values': { }, 'openapi_types': { 'currency_conversion': (InputCurrencyConversion,), }, 'attribute_map': { }, 'location_map': { 'currency_conversion': 'body', }, 'collection_format_map': { } }, headers_map={ 'accept': [ 'application/json' ], 'content_type': [ 'application/json' ] }, api_client=api_client, callable=__convert_currency ) def __format_currency( self, **kwargs ): """Currency - Format currency # noqa: E501 Apply currency symbol to a numeric value # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.format_currency(async_req=True) >>> result = thread.get() Keyword Args: currency_format (InputCurrencyFormat): [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 (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: OutputString 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.call_with_http_info(**kwargs) self.format_currency = Endpoint( settings={ 'response_type': (OutputString,), 'auth': [ 'apiKeyHeader' ], 'endpoint_path': '/FormatCurrency', 'operation_id': 'format_currency', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'currency_format', ], 'required': [], 'nullable': [ ], 'enum': [ ], 'validation': [ ] }, root_map={ 'validations': { }, 'allowed_values': { }, 'openapi_types': { 'currency_format': (InputCurrencyFormat,), }, 'attribute_map': { }, 'location_map': { 'currency_format': 'body', }, 'collection_format_map': { } }, headers_map={ 'accept': [ 'application/json' ], 'content_type': [ 'application/json' ] }, api_client=api_client, callable=__format_currency ) def __market_index( self, **kwargs ): """Finance - Market index # noqa: E501 Get current and historical market index information # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.market_index(async_req=True) >>> result = thread.get() Keyword Args: market_index (InputMarketIndex): [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 (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: OutputMarketIndex 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.call_with_http_info(**kwargs) self.market_index = Endpoint( settings={ 'response_type': (OutputMarketIndex,), 'auth': [ 'apiKeyHeader' ], 'endpoint_path': '/MarketIndex', 'operation_id': 'market_index', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'market_index', ], 'required': [], 'nullable': [ ], 'enum': [ ], 'validation': [ ] }, root_map={ 'validations': { }, 'allowed_values': { }, 'openapi_types': { 'market_index': (InputMarketIndex,), }, 'attribute_map': { }, 'location_map': { 'market_index': 'body', }, 'collection_format_map': { } }, headers_map={ 'accept': [ 'application/json' ], 'content_type': [ 'application/json' ] }, api_client=api_client, callable=__market_index ) def __stock_prices( self, **kwargs ): """Finance - Stock prices # noqa: E501 Get current and historical stock price information # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.stock_prices(async_req=True) >>> result = thread.get() Keyword Args: stock_prices (InputStockPrices): [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 (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: OutputStockPrice 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.call_with_http_info(**kwargs) self.stock_prices = Endpoint( settings={ 'response_type': (OutputStockPrice,), 'auth': [ 'apiKeyHeader' ], 'endpoint_path': '/StockPrices', 'operation_id': 'stock_prices', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'stock_prices', ], 'required': [], 'nullable': [ ], 'enum': [ ], 'validation': [ ] }, root_map={ 'validations': { }, 'allowed_values': { }, 'openapi_types': { 'stock_prices': (InputStockPrices,), }, 'attribute_map': { }, 'location_map': { 'stock_prices': 'body', }, 'collection_format_map': { } }, headers_map={ 'accept': [ 'application/json' ], 'content_type': [ 'application/json' ] }, api_client=api_client, callable=__stock_prices )
def __init__(self, api_client=None): if api_client is None: api_client = ApiClient() self.api_client = api_client def __v1_positions_get(self, **kwargs): """Get open positions # noqa: E501 Get current open positions across all or single exchange. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.v1_positions_get(async_req=True) >>> result = thread.get() Keyword Args: exchange_id (str): Filter the balances to the specific exchange.. [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 (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: Positions 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.call_with_http_info(**kwargs) self.v1_positions_get = Endpoint( settings={ 'response_type': (Positions, ), 'auth': [], 'endpoint_path': '/v1/positions', 'operation_id': 'v1_positions_get', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'exchange_id', ], 'required': [], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'exchange_id': (str, ), }, 'attribute_map': { 'exchange_id': 'exchange_id', }, 'location_map': { 'exchange_id': 'query', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json', 'appliction/json'], 'content_type': [], }, api_client=api_client, callable=__v1_positions_get)
def __init__(self, api_client=None): if api_client is None: api_client = ApiClient() self.api_client = api_client def __raadpleeg_actueel_wozobject( self, identificatie, **kwargs ): """Raadpleeg een WOZ-object # noqa: E501 Raadpleeg de actuele eigenschappen van een WOZ-object # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.raadpleeg_actueel_wozobject(identificatie, async_req=True) >>> result = thread.get() Args: identificatie (str): Unieke identificatie van een WOZ-object Keyword Args: fields (str): Hiermee kun je de inhoud van de resource naar behoefte aanpassen door een door komma's gescheiden lijst van property namen op te geven. Bij opgave van niet-bestaande properties wordt een 400 Bad Request teruggegeven. Wanneer de fields parameter niet is opgegeven, worden alle properties met een waarde teruggegeven. Zie [functionele specificaties](https://github.com/VNG-Realisatie/Haal-Centraal-common/blob/v1.2.0/features/fields.feature). [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 (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: WozObjectHal 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') kwargs['identificatie'] = \ identificatie return self.call_with_http_info(**kwargs) self.raadpleeg_actueel_wozobject = Endpoint( settings={ 'response_type': (WozObjectHal,), 'auth': [], 'endpoint_path': '/wozobjecten/{identificatie}', 'operation_id': 'raadpleeg_actueel_wozobject', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'identificatie', 'fields', ], 'required': [ 'identificatie', ], 'nullable': [ ], 'enum': [ ], 'validation': [ ] }, root_map={ 'validations': { }, 'allowed_values': { }, 'openapi_types': { 'identificatie': (str,), 'fields': (str,), }, 'attribute_map': { 'identificatie': 'identificatie', 'fields': 'fields', }, 'location_map': { 'identificatie': 'path', 'fields': 'query', }, 'collection_format_map': { } }, headers_map={ 'accept': [ 'application/hal+json', 'application/problem+json' ], 'content_type': [], }, api_client=api_client, callable=__raadpleeg_actueel_wozobject ) def __zoek_actuele_wozobjecten( self, **kwargs ): """Zoek WOZ-objecten # noqa: E501 Zoek WOZ-objecten op eigenaar of adres. Het resultaat zijn de actuele gegevens van de gevonden objecten. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.zoek_actuele_wozobjecten(async_req=True) >>> result = thread.get() Keyword Args: rsin (str): Zoek WOZ-objecten in eigendom van een bij het Handelsregister ingeschreven niet-natuurlijk persoon. [optional] kvk_nummer (str): Zoek WOZ-objecten in eigendom van een bij het Handelsregister ingeschreven maatschappelijke activiteit of een van de daaronder vallende ondernemingen en vestigingen. [optional] adresseerbaar_object_identificatie (str): Zoek op de BAG identificatie van een adresseerbaar object (verblijfsobject, standplaats of ligplaats) waar het WOZ-object aan verbonden is of waar het object zijn aanduiding aan ontleent. [optional] nummeraanduiding_identificatie (str): Zoek op de BAG identificatie van een nummeraanduiding (adres) waarmee het WOZ-object wordt aangeduid. [optional] postcode (str): Zoek WOZ-objecten met postcode. [optional] huisnummer (int): Zoek WOZ-objecten met huisnummer\". [optional] fields (str): Hiermee kun je de inhoud van de resource naar behoefte aanpassen door een door komma's gescheiden lijst van property namen op te geven. Bij opgave van niet-bestaande properties wordt een 400 Bad Request teruggegeven. Wanneer de fields parameter niet is opgegeven, worden alle properties met een waarde teruggegeven. Zie [functionele specificaties](https://github.com/VNG-Realisatie/Haal-Centraal-common/blob/v1.2.0/features/fields.feature). [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 (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: WozObjectHalCollectie 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.call_with_http_info(**kwargs) self.zoek_actuele_wozobjecten = Endpoint( settings={ 'response_type': (WozObjectHalCollectie,), 'auth': [], 'endpoint_path': '/wozobjecten', 'operation_id': 'zoek_actuele_wozobjecten', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'rsin', 'kvk_nummer', 'adresseerbaar_object_identificatie', 'nummeraanduiding_identificatie', 'postcode', 'huisnummer', 'fields', ], 'required': [], 'nullable': [ ], 'enum': [ ], 'validation': [ 'postcode', 'huisnummer', ] }, root_map={ 'validations': { ('postcode',): { 'regex': { 'pattern': r'^[1-9][0-9][0-9][0-9][A-Z][A-Z]$', # noqa: E501 }, }, ('huisnummer',): { 'inclusive_maximum': 99999, 'inclusive_minimum': 1, }, }, 'allowed_values': { }, 'openapi_types': { 'rsin': (str,), 'kvk_nummer': (str,), 'adresseerbaar_object_identificatie': (str,), 'nummeraanduiding_identificatie': (str,), 'postcode': (str,), 'huisnummer': (int,), 'fields': (str,), }, 'attribute_map': { 'rsin': 'rsin', 'kvk_nummer': 'kvkNummer', 'adresseerbaar_object_identificatie': 'adresseerbaarObjectIdentificatie', 'nummeraanduiding_identificatie': 'nummeraanduidingIdentificatie', 'postcode': 'postcode', 'huisnummer': 'huisnummer', 'fields': 'fields', }, 'location_map': { 'rsin': 'query', 'kvk_nummer': 'query', 'adresseerbaar_object_identificatie': 'query', 'nummeraanduiding_identificatie': 'query', 'postcode': 'query', 'huisnummer': 'query', 'fields': 'query', }, 'collection_format_map': { } }, headers_map={ 'accept': [ 'application/hal+json', 'application/problem+json' ], 'content_type': [], }, api_client=api_client, callable=__zoek_actuele_wozobjecten )
def __init__(self, api_client=None): if api_client is None: api_client = ApiClient() self.api_client = api_client def __convert_image(self, file, format="PNG", **kwargs): """Files - Convert Image # noqa: E501 Convert an image from one format to another # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.convert_image(file, format="PNG", async_req=True) >>> result = thread.get() Args: file (file_type): Source image file format (str): Output file format. defaults to "PNG", must be one of ["PNG"] Keyword Args: _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 (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: file_type 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') kwargs['format'] = \ format kwargs['file'] = \ file return self.call_with_http_info(**kwargs) self.convert_image = Endpoint( settings={ 'response_type': (file_type, ), 'auth': ['apiKeyHeader'], 'endpoint_path': '/ConvertImage', 'operation_id': 'convert_image', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'format', 'file', ], 'required': [ 'format', 'file', ], 'nullable': [], 'enum': [ 'format', ], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': { ('format', ): { "PNG": "PNG", "JPG": "JPG", "GIF": "GIF", "BMP": "BMP", "TIF": "TIF" }, }, 'openapi_types': { 'format': (str, ), 'file': (file_type, ), }, 'attribute_map': { 'format': 'format', 'file': 'file', }, 'location_map': { 'format': 'form', 'file': 'form', }, 'collection_format_map': {} }, headers_map={ 'accept': ['image/png', 'image/gif', 'image/jpeg', 'image/bmp'], 'content_type': ['multipart/form-data'] }, api_client=api_client, callable=__convert_image) def __crop_image(self, width, height, file, position="TopLeft", **kwargs): """Files - Crop Image # noqa: E501 Crop an image # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.crop_image(width, height, file, position="TopLeft", async_req=True) >>> result = thread.get() Args: width (float): Width (X-axis right, negative to reverse) height (float): Height (Y-axis down, negative to reverse) file (file_type): Source image file position (str): Crop start position (use negative values to reverse crop area). defaults to "TopLeft", must be one of ["TopLeft"] Keyword Args: _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 (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: file_type 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') kwargs['position'] = \ position kwargs['width'] = \ width kwargs['height'] = \ height kwargs['file'] = \ file return self.call_with_http_info(**kwargs) self.crop_image = Endpoint( settings={ 'response_type': (file_type, ), 'auth': ['apiKeyHeader'], 'endpoint_path': '/CropImage', 'operation_id': 'crop_image', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'position', 'width', 'height', 'file', ], 'required': [ 'position', 'width', 'height', 'file', ], 'nullable': [], 'enum': [ 'position', ], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': { ('position', ): { "TOPLEFT": "TopLeft", "TOPCENTER": "TopCenter", "TOPRIGHT": "TopRight", "MIDDLELEFT": "MiddleLeft", "MIDDLECENTER": "MiddleCenter", "MIDDLERIGHT": "MiddleRight", "BOTTOMLEFT": "BottomLeft", "BOTTOMCENTER": "BottomCenter", "BOTTOMRIGHT": "BottomRight" }, }, 'openapi_types': { 'position': (str, ), 'width': (float, ), 'height': (float, ), 'file': (file_type, ), }, 'attribute_map': { 'position': 'position', 'width': 'Width', 'height': 'Height', 'file': 'file', }, 'location_map': { 'position': 'form', 'width': 'form', 'height': 'form', 'file': 'form', }, 'collection_format_map': {} }, headers_map={ 'accept': ['image/png', 'image/gif', 'image/jpeg', 'image/bmp'], 'content_type': ['multipart/form-data'] }, api_client=api_client, callable=__crop_image) def __file_to_string(self, file, **kwargs): """Files - File to string # noqa: E501 Convert a file to a Base64 string # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.file_to_string(file, async_req=True) >>> result = thread.get() Args: file (file_type): Source file (10MB limit) Keyword Args: _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 (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: OutputString 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') kwargs['file'] = \ file return self.call_with_http_info(**kwargs) self.file_to_string = Endpoint(settings={ 'response_type': (OutputString, ), 'auth': ['apiKeyHeader'], 'endpoint_path': '/FileToString', 'operation_id': 'file_to_string', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'file', ], 'required': [ 'file', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'file': (file_type, ), }, 'attribute_map': { 'file': 'file', }, 'location_map': { 'file': 'form', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': ['multipart/form-data'] }, api_client=api_client, callable=__file_to_string) def __flip_image(self, file, orientation="Horizontal", **kwargs): """Files - Flip Image # noqa: E501 Flip an image (horizontal or vertical) # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.flip_image(file, orientation="Horizontal", async_req=True) >>> result = thread.get() Args: file (file_type): Source image file orientation (str): Horizontal or Vertical. defaults to "Horizontal", must be one of ["Horizontal"] Keyword Args: _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 (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: file_type 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') kwargs['orientation'] = \ orientation kwargs['file'] = \ file return self.call_with_http_info(**kwargs) self.flip_image = Endpoint(settings={ 'response_type': (file_type, ), 'auth': ['apiKeyHeader'], 'endpoint_path': '/FlipImage', 'operation_id': 'flip_image', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'orientation', 'file', ], 'required': [ 'orientation', 'file', ], 'nullable': [], 'enum': [ 'orientation', ], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': { ('orientation', ): { "HORIZONTAL": "Horizontal", "VERTICAL": "Vertical" }, }, 'openapi_types': { 'orientation': (str, ), 'file': (file_type, ), }, 'attribute_map': { 'orientation': 'orientation', 'file': 'file', }, 'location_map': { 'orientation': 'form', 'file': 'form', }, 'collection_format_map': {} }, headers_map={ 'accept': ['*/*'], 'content_type': ['multipart/form-data'] }, api_client=api_client, callable=__flip_image) def __generate_qr_code(self, **kwargs): """Files - Generate QR code # noqa: E501 Generate a QR code image # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.generate_qr_code(async_req=True) >>> result = thread.get() Keyword Args: input_qr_code (InputQRCode): [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 (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: file_type 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.call_with_http_info(**kwargs) self.generate_qr_code = Endpoint(settings={ 'response_type': (file_type, ), 'auth': ['apiKeyHeader'], 'endpoint_path': '/GenerateQRCode', 'operation_id': 'generate_qr_code', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'input_qr_code', ], 'required': [], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'input_qr_code': (InputQRCode, ), }, 'attribute_map': {}, 'location_map': { 'input_qr_code': 'body', }, 'collection_format_map': {} }, headers_map={ 'accept': ['image/png'], 'content_type': ['application/json'] }, api_client=api_client, callable=__generate_qr_code) def __resize_image(self, file, algorithm="Bicubic (default)", units="Pixels", **kwargs): """Files - Resize Image # noqa: E501 Resize an image # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.resize_image(file, algorithm="Bicubic (default)", units="Pixels", async_req=True) >>> result = thread.get() Args: file (file_type): Source image file algorithm (str): Optimize output quality of the target image. defaults to "Bicubic (default)", must be one of ["Bicubic (default)"] units (str): Image adjustment units. defaults to "Pixels", must be one of ["Pixels"] Keyword Args: height (float): Image height (pixels or percent). [optional] width (float): Image width (pixels or percent). [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 (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: file_type 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') kwargs['algorithm'] = \ algorithm kwargs['units'] = \ units kwargs['file'] = \ file return self.call_with_http_info(**kwargs) self.resize_image = Endpoint( settings={ 'response_type': (file_type, ), 'auth': ['apiKeyHeader'], 'endpoint_path': '/ResizeImage', 'operation_id': 'resize_image', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'algorithm', 'units', 'file', 'height', 'width', ], 'required': [ 'algorithm', 'units', 'file', ], 'nullable': [], 'enum': [ 'algorithm', 'units', ], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': { ('algorithm', ): { "BICUBIC_(DEFAULT)": "Bicubic (default)", "BILINEAR": "Bilinear", "CUBIC_(BOX)": "Cubic (Box)", "CUBIC_(CATMULL-ROM)": "Cubic (Catmull-Rom)", "CUBIC_(HERMITE)": "Cubic (Hermite)", "CUBIC_(SPLINE)": "Cubic (Spline)", "NEAREST_NEIGHBOR": "Nearest Neighbor", "SINC_(LANCZOS2)": "Sinc (Lanczos2)", "SINC_(LANCZOS3)": "Sinc (Lanczos3)", "SINC_(LANCZOS5)": "Sinc (Lanczos5)", "SINC_(LANCZOS8)": "Sinc (Lanczos8)", "ROBIDOUX": "Robidoux", "ROBIDOUX_SHARP": "Robidoux Sharp" }, ('units', ): { "PIXELS": "Pixels", "PERCENT": "Percent" }, }, 'openapi_types': { 'algorithm': (str, ), 'units': (str, ), 'file': (file_type, ), 'height': (float, ), 'width': (float, ), }, 'attribute_map': { 'algorithm': 'algorithm', 'units': 'units', 'file': 'file', 'height': 'height', 'width': 'width', }, 'location_map': { 'algorithm': 'form', 'units': 'form', 'file': 'form', 'height': 'form', 'width': 'form', }, 'collection_format_map': {} }, headers_map={ 'accept': ['image/png', 'image/gif', 'image/jpeg', 'image/bmp'], 'content_type': ['multipart/form-data'] }, api_client=api_client, callable=__resize_image) def __rotate_image(self, degrees, file, **kwargs): """Files - Rotate Image # noqa: E501 Rotate an image by specified number of degrees # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.rotate_image(degrees, file, async_req=True) >>> result = thread.get() Args: degrees (str): Number of degrees file (file_type): Source image file Keyword Args: _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 (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: file_type 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') kwargs['degrees'] = \ degrees kwargs['file'] = \ file return self.call_with_http_info(**kwargs) self.rotate_image = Endpoint(settings={ 'response_type': (file_type, ), 'auth': ['apiKeyHeader'], 'endpoint_path': '/RotateImage', 'operation_id': 'rotate_image', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'degrees', 'file', ], 'required': [ 'degrees', 'file', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'degrees': (str, ), 'file': (file_type, ), }, 'attribute_map': { 'degrees': 'degrees', 'file': 'file', }, 'location_map': { 'degrees': 'form', 'file': 'form', }, 'collection_format_map': {} }, headers_map={ 'accept': ['*/*'], 'content_type': ['multipart/form-data'] }, api_client=api_client, callable=__rotate_image) def __watermark_image(self, text, size, file, font="Arial", color="000000", horizontal="Center", vertical="Center", **kwargs): """Files - Watermark Image # noqa: E501 Add watermark text to an image # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.watermark_image(text, size, file, font="Arial", color="000000", horizontal="Center", vertical="Center", async_req=True) >>> result = thread.get() Args: text (str): Watermark text size (float): Font size (points) file (file_type): Source image file font (str): Text font. defaults to "Arial", must be one of ["Arial"] color (str): Text color hex value. defaults to "000000", must be one of ["000000"] horizontal (str): Horizontal alignment. defaults to "Center", must be one of ["Center"] vertical (str): Vertical alignment. defaults to "Center", must be one of ["Center"] Keyword Args: _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 (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: file_type 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') kwargs['text'] = \ text kwargs['font'] = \ font kwargs['size'] = \ size kwargs['color'] = \ color kwargs['horizontal'] = \ horizontal kwargs['vertical'] = \ vertical kwargs['file'] = \ file return self.call_with_http_info(**kwargs) self.watermark_image = Endpoint( settings={ 'response_type': (file_type, ), 'auth': ['apiKeyHeader'], 'endpoint_path': '/WatermarkImage', 'operation_id': 'watermark_image', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'text', 'font', 'size', 'color', 'horizontal', 'vertical', 'file', ], 'required': [ 'text', 'font', 'size', 'color', 'horizontal', 'vertical', 'file', ], 'nullable': [], 'enum': [ 'font', 'horizontal', 'vertical', ], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': { ('font', ): { "ARIAL": "Arial", "ARIAL_BLACK": "Arial Black", "ARIAL_NARROW": "Arial Narrow", "BOOK_ANTIQUA": "Book Antiqua", "BRITANNIC_BOLD": "Britannic Bold", "BRUSH_SCRIPT_MT": "Brush Script MT", "CALISTO_MT": "Calisto MT", "CENTURY_GOTHIC": "Century Gothic", "CENTURY_SCHOOLBOOK": "Century Schoolbook", "COLONNA_MT": "Colonna MT", "COMIC_SANS_MS": "Comic Sans MS", "COOPER_BLACK": "Cooper Black", "COPPERPLATE_GOTHIC_BOLD": "Copperplate Gothic Bold", "COPPERPLATE_GOTHIC_LIGHT": "Copperplate Gothic Light", "COURIER_NEW": "Courier New", "EDWARDIAN_SCRIPT_ITC": "Edwardian Script ITC", "ENGRAVERS_MT": "Engravers MT", "FRANKLIN_GOTHIC_DEMI": "Franklin Gothic Demi", "FRANKLIN_GOTHIC_HEAVY": "Franklin Gothic Heavy", "FRANKLIN_GOTHIC_MEDIUM": "Franklin Gothic Medium", "GARAMOND": "Garamond", "GEORGIA": "Georgia", "GILL_SANS_MT": "Gill Sans MT", "GILL_SANS_MT_CONDENSED": "Gill Sans MT Condensed", "GILL_SANS_ULTRA_BOLD": "Gill Sans Ultra Bold", "GILL_SANS_ULTRA_BOLD_CONDENSED": "Gill Sans Ultra Bold Condensed", "GOUDY_OLD_STYLE": "Goudy Old Style", "HAETTENSCHWEILER": "Haettenschweiler", "HOLIDAYS_MT": "Holidays MT", "IMPACT": "Impact", "LUCIDA_CALLIGRAPHY": "Lucida Calligraphy", "LUCIDA_CONSOLE": "Lucida Console", "LUCIDA_HANDWRITING": "Lucida Handwriting", "LUCIDA_SANS_TYPEWRITER": "Lucida Sans Typewriter", "LUCIDA_SANS_UNICODE": "Lucida Sans Unicode", "MARLETT": "Marlett", "MICROSOFT_SANS_SERIF": "Microsoft Sans Serif", "MS_OUTLOOK": "MS Outlook", "PALACE_SCRIPT_MT": "Palace Script MT", "PALATINO_LINOTYPE": "Palatino Linotype", "PAPYRUS": "Papyrus", "PLAYBILL": "Playbill", "ROCKWELL": "Rockwell", "ROCKWELL_CONDENSED": "Rockwell Condensed", "ROCKWELL_EXTRA_BOLD": "Rockwell Extra Bold", "SCRIPT_MT_BOLD": "Script MT Bold", "STENCIL": "Stencil", "SYMBOL": "Symbol", "TAHOMA": "Tahoma", "TIMES_NEW_ROMAN": "Times New Roman", "TREBUCHET_MS": "Trebuchet MS", "VERDANA": "Verdana", "VIVALDI": "Vivaldi", "WEBDINGS": "Webdings", "WINGDINGS_1": "Wingdings 1", "WINGDINGS_2": "Wingdings 2", "WINGDINGS_3": "Wingdings 3" }, ('horizontal', ): { "LEFT": "Left", "CENTER": "Center", "RIGHT": "Right" }, ('vertical', ): { "TOP": "Top", "CENTER": "Center", "BOTTOM": "Bottom" }, }, 'openapi_types': { 'text': (str, ), 'font': (str, ), 'size': (float, ), 'color': (str, ), 'horizontal': (str, ), 'vertical': (str, ), 'file': (file_type, ), }, 'attribute_map': { 'text': 'text', 'font': 'font', 'size': 'size', 'color': 'color', 'horizontal': 'horizontal', 'vertical': 'vertical', 'file': 'file', }, 'location_map': { 'text': 'form', 'font': 'form', 'size': 'form', 'color': 'form', 'horizontal': 'form', 'vertical': 'form', 'file': 'form', }, 'collection_format_map': {} }, headers_map={ 'accept': ['*/*'], 'content_type': ['multipart/form-data'] }, api_client=api_client, callable=__watermark_image)
def __init__(self, api_client=None): if api_client is None: api_client = ApiClient() self.api_client = api_client def __v1_orders_cancel_all_post( self, order_cancel_all_request, **kwargs ): """Cancel all orders request # noqa: E501 This request cancels all open orders on single specified exchange. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.v1_orders_cancel_all_post(order_cancel_all_request, async_req=True) >>> result = thread.get() Args: order_cancel_all_request (OrderCancelAllRequest): OrderCancelAllRequest object. Keyword Args: _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 (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: Message 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') kwargs['order_cancel_all_request'] = \ order_cancel_all_request return self.call_with_http_info(**kwargs) self.v1_orders_cancel_all_post = Endpoint( settings={ 'response_type': (Message,), 'auth': [], 'endpoint_path': '/v1/orders/cancel/all', 'operation_id': 'v1_orders_cancel_all_post', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'order_cancel_all_request', ], 'required': [ 'order_cancel_all_request', ], 'nullable': [ ], 'enum': [ ], 'validation': [ ] }, root_map={ 'validations': { }, 'allowed_values': { }, 'openapi_types': { 'order_cancel_all_request': (OrderCancelAllRequest,), }, 'attribute_map': { }, 'location_map': { 'order_cancel_all_request': 'body', }, 'collection_format_map': { } }, headers_map={ 'accept': [ 'application/json', 'appliction/json' ], 'content_type': [ 'application/json' ] }, api_client=api_client, callable=__v1_orders_cancel_all_post ) def __v1_orders_cancel_post( self, order_cancel_single_request, **kwargs ): """Cancel order request # noqa: E501 Request cancel for an existing order. The order can be canceled using the `client_order_id` or `exchange_order_id`. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.v1_orders_cancel_post(order_cancel_single_request, async_req=True) >>> result = thread.get() Args: order_cancel_single_request (OrderCancelSingleRequest): OrderCancelSingleRequest object. Keyword Args: _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 (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: OrderExecutionReport 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') kwargs['order_cancel_single_request'] = \ order_cancel_single_request return self.call_with_http_info(**kwargs) self.v1_orders_cancel_post = Endpoint( settings={ 'response_type': (OrderExecutionReport,), 'auth': [], 'endpoint_path': '/v1/orders/cancel', 'operation_id': 'v1_orders_cancel_post', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'order_cancel_single_request', ], 'required': [ 'order_cancel_single_request', ], 'nullable': [ ], 'enum': [ ], 'validation': [ ] }, root_map={ 'validations': { }, 'allowed_values': { }, 'openapi_types': { 'order_cancel_single_request': (OrderCancelSingleRequest,), }, 'attribute_map': { }, 'location_map': { 'order_cancel_single_request': 'body', }, 'collection_format_map': { } }, headers_map={ 'accept': [ 'application/json', 'appliction/json' ], 'content_type': [ 'application/json' ] }, api_client=api_client, callable=__v1_orders_cancel_post ) def __v1_orders_get( self, **kwargs ): """Get open orders # noqa: E501 Get last execution reports for open orders across all or single exchange. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.v1_orders_get(async_req=True) >>> result = thread.get() Keyword Args: exchange_id (str): Filter the open orders to the specific exchange.. [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 (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: OrderExecutionReports 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.call_with_http_info(**kwargs) self.v1_orders_get = Endpoint( settings={ 'response_type': (OrderExecutionReports,), 'auth': [], 'endpoint_path': '/v1/orders', 'operation_id': 'v1_orders_get', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'exchange_id', ], 'required': [], 'nullable': [ ], 'enum': [ ], 'validation': [ ] }, root_map={ 'validations': { }, 'allowed_values': { }, 'openapi_types': { 'exchange_id': (str,), }, 'attribute_map': { 'exchange_id': 'exchange_id', }, 'location_map': { 'exchange_id': 'query', }, 'collection_format_map': { } }, headers_map={ 'accept': [ 'application/json', 'appliction/json' ], 'content_type': [], }, api_client=api_client, callable=__v1_orders_get ) def __v1_orders_post( self, order_new_single_request, **kwargs ): """Send new order # noqa: E501 This request creating new order for the specific exchange. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.v1_orders_post(order_new_single_request, async_req=True) >>> result = thread.get() Args: order_new_single_request (OrderNewSingleRequest): OrderNewSingleRequest object. Keyword Args: _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 (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: OrderExecutionReport 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') kwargs['order_new_single_request'] = \ order_new_single_request return self.call_with_http_info(**kwargs) self.v1_orders_post = Endpoint( settings={ 'response_type': (OrderExecutionReport,), 'auth': [], 'endpoint_path': '/v1/orders', 'operation_id': 'v1_orders_post', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'order_new_single_request', ], 'required': [ 'order_new_single_request', ], 'nullable': [ ], 'enum': [ ], 'validation': [ ] }, root_map={ 'validations': { }, 'allowed_values': { }, 'openapi_types': { 'order_new_single_request': (OrderNewSingleRequest,), }, 'attribute_map': { }, 'location_map': { 'order_new_single_request': 'body', }, 'collection_format_map': { } }, headers_map={ 'accept': [ 'application/json', 'appliction/json' ], 'content_type': [ 'application/json' ] }, api_client=api_client, callable=__v1_orders_post ) def __v1_orders_status_client_order_id_get( self, client_order_id, **kwargs ): """Get order execution report # noqa: E501 Get the last order execution report for the specified order. The requested order does not need to be active or opened. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.v1_orders_status_client_order_id_get(client_order_id, async_req=True) >>> result = thread.get() Args: client_order_id (str): The unique identifier of the order assigned by the client. Keyword Args: _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 (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: OrderExecutionReport 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') kwargs['client_order_id'] = \ client_order_id return self.call_with_http_info(**kwargs) self.v1_orders_status_client_order_id_get = Endpoint( settings={ 'response_type': (OrderExecutionReport,), 'auth': [], 'endpoint_path': '/v1/orders/status/{client_order_id}', 'operation_id': 'v1_orders_status_client_order_id_get', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'client_order_id', ], 'required': [ 'client_order_id', ], 'nullable': [ ], 'enum': [ ], 'validation': [ ] }, root_map={ 'validations': { }, 'allowed_values': { }, 'openapi_types': { 'client_order_id': (str,), }, 'attribute_map': { 'client_order_id': 'client_order_id', }, 'location_map': { 'client_order_id': 'path', }, 'collection_format_map': { } }, headers_map={ 'accept': [ 'application/json' ], 'content_type': [], }, api_client=api_client, callable=__v1_orders_status_client_order_id_get )
def __init__(self, api_client=None): if api_client is None: api_client = ApiClient() self.api_client = api_client def __create_user_users_post(self, user_input, **kwargs): """Create User # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.create_user_users_post(user_input, async_req=True) >>> result = thread.get() Args: user_input (UserInput): Keyword Args: _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 (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: bool, date, datetime, dict, float, int, list, str, none_type 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') kwargs['user_input'] = \ user_input return self.call_with_http_info(**kwargs) self.create_user_users_post = Endpoint( settings={ 'response_type': ( bool, date, datetime, dict, float, int, list, str, none_type, ), 'auth': [], 'endpoint_path': '/users/', 'operation_id': 'create_user_users_post', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'user_input', ], 'required': [ 'user_input', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'user_input': (UserInput, ), }, 'attribute_map': {}, 'location_map': { 'user_input': 'body', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': ['application/json'] }, api_client=api_client, callable=__create_user_users_post) def __delete_user_users_user_id_delete(self, user_id, **kwargs): """Delete User # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.delete_user_users_user_id_delete(user_id, async_req=True) >>> result = thread.get() Args: user_id (str): Keyword Args: _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 (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: bool, date, datetime, dict, float, int, list, str, none_type 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') kwargs['user_id'] = \ user_id return self.call_with_http_info(**kwargs) self.delete_user_users_user_id_delete = Endpoint( settings={ 'response_type': ( bool, date, datetime, dict, float, int, list, str, none_type, ), 'auth': [], 'endpoint_path': '/users/{user_id}', 'operation_id': 'delete_user_users_user_id_delete', 'http_method': 'DELETE', 'servers': None, }, params_map={ 'all': [ 'user_id', ], 'required': [ 'user_id', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'user_id': (str, ), }, 'attribute_map': { 'user_id': 'user_id', }, 'location_map': { 'user_id': 'path', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__delete_user_users_user_id_delete) def __read_user_users_user_id_get(self, user_id, **kwargs): """Read User # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.read_user_users_user_id_get(user_id, async_req=True) >>> result = thread.get() Args: user_id (str): Keyword Args: _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 (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: bool, date, datetime, dict, float, int, list, str, none_type 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') kwargs['user_id'] = \ user_id return self.call_with_http_info(**kwargs) self.read_user_users_user_id_get = Endpoint( settings={ 'response_type': ( bool, date, datetime, dict, float, int, list, str, none_type, ), 'auth': [], 'endpoint_path': '/users/{user_id}', 'operation_id': 'read_user_users_user_id_get', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'user_id', ], 'required': [ 'user_id', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'user_id': (str, ), }, 'attribute_map': { 'user_id': 'user_id', }, 'location_map': { 'user_id': 'path', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__read_user_users_user_id_get)
def __init__(self, api_client=None): if api_client is None: api_client = ApiClient() self.api_client = api_client def __create_posts(self, **kwargs): """Create a post # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.create_posts(async_req=True) >>> result = thread.get() Keyword Args: _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 (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: None 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.call_with_http_info(**kwargs) self.create_posts = Endpoint(settings={ 'response_type': None, 'auth': [], 'endpoint_path': '/posts', 'operation_id': 'create_posts', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [], 'required': [], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': {}, 'attribute_map': {}, 'location_map': {}, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__create_posts) def __fetch_posts(self, **kwargs): """List all posts # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.fetch_posts(async_req=True) >>> result = thread.get() Keyword Args: limit (int): How many items to return at one time (max 100). [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 (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: Posts 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.call_with_http_info(**kwargs) self.fetch_posts = Endpoint(settings={ 'response_type': (Posts, ), 'auth': [], 'endpoint_path': '/posts', 'operation_id': 'fetch_posts', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'limit', ], 'required': [], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'limit': (int, ), }, 'attribute_map': { 'limit': 'limit', }, 'location_map': { 'limit': 'query', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__fetch_posts) def __get_post_by_id(self, id, **kwargs): """Info for a specific post # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_post_by_id(id, async_req=True) >>> result = thread.get() Args: id (str): The id of the post to retrieve Keyword Args: _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 (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: Post 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') kwargs['id'] = \ id return self.call_with_http_info(**kwargs) self.get_post_by_id = Endpoint(settings={ 'response_type': (Post, ), 'auth': [], 'endpoint_path': '/posts/{id}', 'operation_id': 'get_post_by_id', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'id', ], 'required': [ 'id', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'id': (str, ), }, 'attribute_map': { 'id': 'id', }, 'location_map': { 'id': 'path', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__get_post_by_id)
def __init__(self, api_client=None): if api_client is None: api_client = ApiClient() self.api_client = api_client def __getnationaliteithistorie(self, burgerservicenummer, **kwargs): """getnationaliteithistorie # noqa: E501 Zoek de nationaliteithistorie van een persoon op de opgegeven peildatum of binnen de opgegeven periode. Als je geen peildatum of periode opgeeft, krijg je alle nationaliteiten van de persoon terug. De meest actuele nationaliteit staat bovenaan. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.getnationaliteithistorie(burgerservicenummer, async_req=True) >>> result = thread.get() Args: burgerservicenummer (str): Uniek persoonsnummer Keyword Args: fields (str): Hiermee kun je de inhoud van de resource naar behoefte aanpassen door een door komma's gescheiden lijst van property namen op te geven. Bij opgave van niet-bestaande properties wordt een 400 Bad Request teruggegeven. Wanneer de fields parameter niet is opgegeven, worden alle properties met een waarde teruggegeven. Zie [functionele specificaties](https://github.com/VNG-Realisatie/Haal-Centraal-common/blob/v1.2.0/features/fields.feature). [optional] peildatum (date): De datum waarop de resource wordt opgevraagd.. [optional] datum_van (date): De begindatum van de periode waarover de resource wordt opgevraagd.. [optional] datum_tot_en_met (date): De einddatum van de periode waarover de resource wordt opgevraagd.. [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 (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: NationaliteithistorieHalCollectie 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') kwargs['burgerservicenummer'] = \ burgerservicenummer return self.call_with_http_info(**kwargs) self.getnationaliteithistorie = Endpoint( settings={ 'response_type': (NationaliteithistorieHalCollectie, ), 'auth': [], 'endpoint_path': '/ingeschrevenpersonen/{burgerservicenummer}/nationaliteithistorie', 'operation_id': 'getnationaliteithistorie', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'burgerservicenummer', 'fields', 'peildatum', 'datum_van', 'datum_tot_en_met', ], 'required': [ 'burgerservicenummer', ], 'nullable': [], 'enum': [], 'validation': [ 'burgerservicenummer', ] }, root_map={ 'validations': { ('burgerservicenummer', ): { 'max_length': 9, 'min_length': 9, 'regex': { 'pattern': r'^[0-9]*$', # noqa: E501 }, }, }, 'allowed_values': {}, 'openapi_types': { 'burgerservicenummer': (str, ), 'fields': (str, ), 'peildatum': (date, ), 'datum_van': (date, ), 'datum_tot_en_met': (date, ), }, 'attribute_map': { 'burgerservicenummer': 'burgerservicenummer', 'fields': 'fields', 'peildatum': 'peildatum', 'datum_van': 'datumVan', 'datum_tot_en_met': 'datumTotEnMet', }, 'location_map': { 'burgerservicenummer': 'path', 'fields': 'query', 'peildatum': 'query', 'datum_van': 'query', 'datum_tot_en_met': 'query', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/hal+json', 'application/problem+json'], 'content_type': [], }, api_client=api_client, callable=__getnationaliteithistorie) def __getpartnerhistorie(self, burgerservicenummer, **kwargs): """getpartnerhistorie # noqa: E501 Zoek de partnerhistorie van een persoon op de opgegeven peildatum of binnen de opgegeven periode. Als je geen peildatum of periode opgeeft, krijg je alle partners terug waarmee een partnerschap is aangegaan of een huwelijk is gesloten. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.getpartnerhistorie(burgerservicenummer, async_req=True) >>> result = thread.get() Args: burgerservicenummer (str): Uniek persoonsnummer Keyword Args: fields (str): Hiermee kun je de inhoud van de resource naar behoefte aanpassen door een door komma's gescheiden lijst van property namen op te geven. Bij opgave van niet-bestaande properties wordt een 400 Bad Request teruggegeven. Wanneer de fields parameter niet is opgegeven, worden alle properties met een waarde teruggegeven. Zie [functionele specificaties](https://github.com/VNG-Realisatie/Haal-Centraal-common/blob/v1.2.0/features/fields.feature). [optional] peildatum (date): De datum waarop de resource wordt opgevraagd.. [optional] datum_van (date): De begindatum van de periode waarover de resource wordt opgevraagd.. [optional] datum_tot_en_met (date): De einddatum van de periode waarover de resource wordt opgevraagd.. [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 (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: PartnerhistorieHalCollectie 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') kwargs['burgerservicenummer'] = \ burgerservicenummer return self.call_with_http_info(**kwargs) self.getpartnerhistorie = Endpoint( settings={ 'response_type': (PartnerhistorieHalCollectie, ), 'auth': [], 'endpoint_path': '/ingeschrevenpersonen/{burgerservicenummer}/partnerhistorie', 'operation_id': 'getpartnerhistorie', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'burgerservicenummer', 'fields', 'peildatum', 'datum_van', 'datum_tot_en_met', ], 'required': [ 'burgerservicenummer', ], 'nullable': [], 'enum': [], 'validation': [ 'burgerservicenummer', ] }, root_map={ 'validations': { ('burgerservicenummer', ): { 'max_length': 9, 'min_length': 9, 'regex': { 'pattern': r'^[0-9]*$', # noqa: E501 }, }, }, 'allowed_values': {}, 'openapi_types': { 'burgerservicenummer': (str, ), 'fields': (str, ), 'peildatum': (date, ), 'datum_van': (date, ), 'datum_tot_en_met': (date, ), }, 'attribute_map': { 'burgerservicenummer': 'burgerservicenummer', 'fields': 'fields', 'peildatum': 'peildatum', 'datum_van': 'datumVan', 'datum_tot_en_met': 'datumTotEnMet', }, 'location_map': { 'burgerservicenummer': 'path', 'fields': 'query', 'peildatum': 'query', 'datum_van': 'query', 'datum_tot_en_met': 'query', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/hal+json', 'application/problem+json'], 'content_type': [], }, api_client=api_client, callable=__getpartnerhistorie) def __getverblijfplaatshistorie(self, burgerservicenummer, **kwargs): """getverblijfplaatshistorie # noqa: E501 Zoek de verblijfplaatshistorie van een persoon op de opgegeven peildatum of binnen de opgegeven periode. Als je geen peildatum of periode opgeeft, krijg je alle verblijfplaatsen terug. Het meest actuele adres staat bovenaan. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.getverblijfplaatshistorie(burgerservicenummer, async_req=True) >>> result = thread.get() Args: burgerservicenummer (str): Uniek persoonsnummer Keyword Args: fields (str): Hiermee kun je de inhoud van de resource naar behoefte aanpassen door een door komma's gescheiden lijst van property namen op te geven. Bij opgave van niet-bestaande properties wordt een 400 Bad Request teruggegeven. Wanneer de fields parameter niet is opgegeven, worden alle properties met een waarde teruggegeven. Zie [functionele specificaties](https://github.com/VNG-Realisatie/Haal-Centraal-common/blob/v1.2.0/features/fields.feature). [optional] peildatum (date): De datum waarop de resource wordt opgevraagd.. [optional] datum_van (date): De begindatum van de periode waarover de resource wordt opgevraagd.. [optional] datum_tot_en_met (date): De einddatum van de periode waarover de resource wordt opgevraagd.. [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 (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: VerblijfplaatshistorieHalCollectie 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') kwargs['burgerservicenummer'] = \ burgerservicenummer return self.call_with_http_info(**kwargs) self.getverblijfplaatshistorie = Endpoint( settings={ 'response_type': (VerblijfplaatshistorieHalCollectie, ), 'auth': [], 'endpoint_path': '/ingeschrevenpersonen/{burgerservicenummer}/verblijfplaatshistorie', 'operation_id': 'getverblijfplaatshistorie', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'burgerservicenummer', 'fields', 'peildatum', 'datum_van', 'datum_tot_en_met', ], 'required': [ 'burgerservicenummer', ], 'nullable': [], 'enum': [], 'validation': [ 'burgerservicenummer', ] }, root_map={ 'validations': { ('burgerservicenummer', ): { 'max_length': 9, 'min_length': 9, 'regex': { 'pattern': r'^[0-9]*$', # noqa: E501 }, }, }, 'allowed_values': {}, 'openapi_types': { 'burgerservicenummer': (str, ), 'fields': (str, ), 'peildatum': (date, ), 'datum_van': (date, ), 'datum_tot_en_met': (date, ), }, 'attribute_map': { 'burgerservicenummer': 'burgerservicenummer', 'fields': 'fields', 'peildatum': 'peildatum', 'datum_van': 'datumVan', 'datum_tot_en_met': 'datumTotEnMet', }, 'location_map': { 'burgerservicenummer': 'path', 'fields': 'query', 'peildatum': 'query', 'datum_van': 'query', 'datum_tot_en_met': 'query', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/hal+json', 'application/problem+json'], 'content_type': [], }, api_client=api_client, callable=__getverblijfplaatshistorie) def __getverblijfstitelhistorie(self, burgerservicenummer, **kwargs): """getverblijfstitelhistorie # noqa: E501 Zoek de verblijfstitelhistorie van een persoon op de opgegeven peildatum of binnen de opgegeven periode. Als je geen peildatum of periode opgeeft, krijg je alle verblijfstitels van de persoon terug. De meest actuele verblijfstitel staat bovenaan. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.getverblijfstitelhistorie(burgerservicenummer, async_req=True) >>> result = thread.get() Args: burgerservicenummer (str): Uniek persoonsnummer Keyword Args: fields (str): Hiermee kun je de inhoud van de resource naar behoefte aanpassen door een door komma's gescheiden lijst van property namen op te geven. Bij opgave van niet-bestaande properties wordt een 400 Bad Request teruggegeven. Wanneer de fields parameter niet is opgegeven, worden alle properties met een waarde teruggegeven. Zie [functionele specificaties](https://github.com/VNG-Realisatie/Haal-Centraal-common/blob/v1.2.0/features/fields.feature). [optional] peildatum (date): De datum waarop de resource wordt opgevraagd.. [optional] datum_van (date): De begindatum van de periode waarover de resource wordt opgevraagd.. [optional] datum_tot_en_met (date): De einddatum van de periode waarover de resource wordt opgevraagd.. [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 (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: VerblijfstitelhistorieHalCollectie 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') kwargs['burgerservicenummer'] = \ burgerservicenummer return self.call_with_http_info(**kwargs) self.getverblijfstitelhistorie = Endpoint( settings={ 'response_type': (VerblijfstitelhistorieHalCollectie, ), 'auth': [], 'endpoint_path': '/ingeschrevenpersonen/{burgerservicenummer}/verblijfstitelhistorie', 'operation_id': 'getverblijfstitelhistorie', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'burgerservicenummer', 'fields', 'peildatum', 'datum_van', 'datum_tot_en_met', ], 'required': [ 'burgerservicenummer', ], 'nullable': [], 'enum': [], 'validation': [ 'burgerservicenummer', ] }, root_map={ 'validations': { ('burgerservicenummer', ): { 'max_length': 9, 'min_length': 9, 'regex': { 'pattern': r'^[0-9]*$', # noqa: E501 }, }, }, 'allowed_values': {}, 'openapi_types': { 'burgerservicenummer': (str, ), 'fields': (str, ), 'peildatum': (date, ), 'datum_van': (date, ), 'datum_tot_en_met': (date, ), }, 'attribute_map': { 'burgerservicenummer': 'burgerservicenummer', 'fields': 'fields', 'peildatum': 'peildatum', 'datum_van': 'datumVan', 'datum_tot_en_met': 'datumTotEnMet', }, 'location_map': { 'burgerservicenummer': 'path', 'fields': 'query', 'peildatum': 'query', 'datum_van': 'query', 'datum_tot_en_met': 'query', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/hal+json', 'application/problem+json'], 'content_type': [], }, api_client=api_client, callable=__getverblijfstitelhistorie)
def __init__(self, api_client=None): if api_client is None: api_client = ApiClient() self.api_client = api_client def __csv_to_json(self, **kwargs): """Data - CSV to JSON # noqa: E501 Convert a CSV string to a JSON array # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.csv_to_json(async_req=True) >>> result = thread.get() Keyword Args: csv_conversion_json (InputCsvConversionJSON): [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 (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: OutputString 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.call_with_http_info(**kwargs) self.csv_to_json = Endpoint(settings={ 'response_type': (OutputString, ), 'auth': ['apiKeyHeader'], 'endpoint_path': '/CSVtoJSON', 'operation_id': 'csv_to_json', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'csv_conversion_json', ], 'required': [], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'csv_conversion_json': (InputCsvConversionJSON, ), }, 'attribute_map': {}, 'location_map': { 'csv_conversion_json': 'body', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': ['application/json'] }, api_client=api_client, callable=__csv_to_json) def __json_to_csv(self, **kwargs): """Data - JSON to CSV # noqa: E501 Convert a JSON array to CSV string # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.json_to_csv(async_req=True) >>> result = thread.get() Keyword Args: json_conversion_csv (InputJsonConversionCSV): [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 (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: OutputString 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.call_with_http_info(**kwargs) self.json_to_csv = Endpoint(settings={ 'response_type': (OutputString, ), 'auth': ['apiKeyHeader'], 'endpoint_path': '/JSONtoCSV', 'operation_id': 'json_to_csv', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'json_conversion_csv', ], 'required': [], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'json_conversion_csv': (InputJsonConversionCSV, ), }, 'attribute_map': {}, 'location_map': { 'json_conversion_csv': 'body', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': ['application/json'] }, api_client=api_client, callable=__json_to_csv) def __json_to_html(self, **kwargs): """Data - JSON to HTML Table # noqa: E501 Convert a JSON array to an HTML table # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.json_to_html(async_req=True) >>> result = thread.get() Keyword Args: json_conversion_html (InputJsonConversionHTML): [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 (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: OutputString 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.call_with_http_info(**kwargs) self.json_to_html = Endpoint(settings={ 'response_type': (OutputString, ), 'auth': ['apiKeyHeader'], 'endpoint_path': '/JSONtoHTML', 'operation_id': 'json_to_html', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'json_conversion_html', ], 'required': [], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'json_conversion_html': (InputJsonConversionHTML, ), }, 'attribute_map': {}, 'location_map': { 'json_conversion_html': 'body', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': ['application/json'] }, api_client=api_client, callable=__json_to_html) def __json_to_xml(self, **kwargs): """Data - JSON to XML # noqa: E501 Convert a JSON object to an XML string # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.json_to_xml(async_req=True) >>> result = thread.get() Keyword Args: json_conversion_xml (InputJsonConversionXML): [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 (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: OutputString 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.call_with_http_info(**kwargs) self.json_to_xml = Endpoint(settings={ 'response_type': (OutputString, ), 'auth': ['apiKeyHeader'], 'endpoint_path': '/JSONtoXML', 'operation_id': 'json_to_xml', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'json_conversion_xml', ], 'required': [], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'json_conversion_xml': (InputJsonConversionXML, ), }, 'attribute_map': {}, 'location_map': { 'json_conversion_xml': 'body', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': ['application/json'] }, api_client=api_client, callable=__json_to_xml) def __query_json(self, **kwargs): """Data - Query JSON # noqa: E501 Query a JSON object using a JSONPath expression # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.query_json(async_req=True) >>> result = thread.get() Keyword Args: input_data_query (InputDataQuery): [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 (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: OutputString 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.call_with_http_info(**kwargs) self.query_json = Endpoint(settings={ 'response_type': (OutputString, ), 'auth': ['apiKeyHeader'], 'endpoint_path': '/QueryJSON', 'operation_id': 'query_json', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'input_data_query', ], 'required': [], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'input_data_query': (InputDataQuery, ), }, 'attribute_map': {}, 'location_map': { 'input_data_query': 'body', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': ['application/json'] }, api_client=api_client, callable=__query_json) def __query_xml(self, **kwargs): """Data - Query XML # noqa: E501 Query an XML string using an XPath expression # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.query_xml(async_req=True) >>> result = thread.get() Keyword Args: input_data_query (InputDataQuery): [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 (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: OutputString 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.call_with_http_info(**kwargs) self.query_xml = Endpoint(settings={ 'response_type': (OutputString, ), 'auth': ['apiKeyHeader'], 'endpoint_path': '/QueryXML', 'operation_id': 'query_xml', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'input_data_query', ], 'required': [], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'input_data_query': (InputDataQuery, ), }, 'attribute_map': {}, 'location_map': { 'input_data_query': 'body', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': ['application/json'] }, api_client=api_client, callable=__query_xml) def __xml_to_json(self, **kwargs): """Data - XML to JSON # noqa: E501 Convert an XML string to a JSON object # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.xml_to_json(async_req=True) >>> result = thread.get() Keyword Args: xml_conversion_json (InputXmlConversionJSON): [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 (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: OutputString 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.call_with_http_info(**kwargs) self.xml_to_json = Endpoint(settings={ 'response_type': (OutputString, ), 'auth': ['apiKeyHeader'], 'endpoint_path': '/XMLtoJSON', 'operation_id': 'xml_to_json', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'xml_conversion_json', ], 'required': [], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'xml_conversion_json': (InputXmlConversionJSON, ), }, 'attribute_map': {}, 'location_map': { 'xml_conversion_json': 'body', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': ['application/json'] }, api_client=api_client, callable=__xml_to_json)
def __init__(self, api_client=None): if api_client is None: api_client = ApiClient() self.api_client = api_client def __get_volgindicatie(self, burgerservicenummer, **kwargs): """Raadpleeg een volgindicatie op een persoon # noqa: E501 Vraag een volgindicatie op van een specifieke persoon. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_volgindicatie(burgerservicenummer, async_req=True) >>> result = thread.get() Args: burgerservicenummer (bool, date, datetime, dict, float, int, list, str, none_type): Identificerend gegeven van een ingeschreven natuurlijk persoon, als bedoeld in artikel 1.1 van de Wet algemene bepalingen burgerservicenummer. Keyword Args: _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 (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: VolgindicatieRaadplegen 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') kwargs['burgerservicenummer'] = \ burgerservicenummer return self.call_with_http_info(**kwargs) self.get_volgindicatie = Endpoint( settings={ 'response_type': (VolgindicatieRaadplegen, ), 'auth': [], 'endpoint_path': '/volgindicaties/{burgerservicenummer}', 'operation_id': 'get_volgindicatie', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'burgerservicenummer', ], 'required': [ 'burgerservicenummer', ], 'nullable': [], 'enum': [], 'validation': [ 'burgerservicenummer', ] }, root_map={ 'validations': { ('burgerservicenummer', ): { 'max_length': 9, 'min_length': 9, 'regex': { 'pattern': r'^[0-9]*$', # noqa: E501 }, }, }, 'allowed_values': {}, 'openapi_types': { 'burgerservicenummer': ( bool, date, datetime, dict, float, int, list, str, none_type, ), }, 'attribute_map': { 'burgerservicenummer': 'burgerservicenummer', }, 'location_map': { 'burgerservicenummer': 'path', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json', 'application/problem+json'], 'content_type': [], }, api_client=api_client, callable=__get_volgindicatie) def __get_volgindicaties(self, **kwargs): """Raadpleeg actieve volgindicaties # noqa: E501 Vraag de actieve volgindicaties op van een abonnee. Levert geen volgindicaties met einddatum vandaag of in het verleden. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_volgindicaties(async_req=True) >>> result = thread.get() Keyword Args: _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 (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: VolgindicatieCollectie 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.call_with_http_info(**kwargs) self.get_volgindicaties = Endpoint( settings={ 'response_type': (VolgindicatieCollectie, ), 'auth': [], 'endpoint_path': '/volgindicaties', 'operation_id': 'get_volgindicaties', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [], 'required': [], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': {}, 'attribute_map': {}, 'location_map': {}, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json', 'application/problem+json'], 'content_type': [], }, api_client=api_client, callable=__get_volgindicaties) def __upsert_volgindicatie(self, burgerservicenummer, **kwargs): """Plaats, wijzig of beëindig een volgindicatie # noqa: E501 Plaats, wijzig of beëindig een volgindicatie op een specifieke persoon. Als je de persoon nog niet volgt, wordt een volgindicatie geplaatst. Als je de persoon al wel volgt, wordt de volgindicatie gewijzigd. Verwijder de einddatum van een volgindicatie door in de request body een leeg object { } te sturen. Beëindig een volgindicatie door een einddatum gelijk aan de datum van vandaag te sturen. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.upsert_volgindicatie(burgerservicenummer, async_req=True) >>> result = thread.get() Args: burgerservicenummer (bool, date, datetime, dict, float, int, list, str, none_type): Identificerend gegeven van een ingeschreven natuurlijk persoon, als bedoeld in artikel 1.1 van de Wet algemene bepalingen burgerservicenummer. Keyword Args: volgindicatie (Volgindicatie): [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 (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: VolgindicatieRaadplegen 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') kwargs['burgerservicenummer'] = \ burgerservicenummer return self.call_with_http_info(**kwargs) self.upsert_volgindicatie = Endpoint( settings={ 'response_type': (VolgindicatieRaadplegen, ), 'auth': [], 'endpoint_path': '/volgindicaties/{burgerservicenummer}', 'operation_id': 'upsert_volgindicatie', 'http_method': 'PUT', 'servers': None, }, params_map={ 'all': [ 'burgerservicenummer', 'volgindicatie', ], 'required': [ 'burgerservicenummer', ], 'nullable': [], 'enum': [], 'validation': [ 'burgerservicenummer', ] }, root_map={ 'validations': { ('burgerservicenummer', ): { 'max_length': 9, 'min_length': 9, 'regex': { 'pattern': r'^[0-9]*$', # noqa: E501 }, }, }, 'allowed_values': {}, 'openapi_types': { 'burgerservicenummer': ( bool, date, datetime, dict, float, int, list, str, none_type, ), 'volgindicatie': (Volgindicatie, ), }, 'attribute_map': { 'burgerservicenummer': 'burgerservicenummer', }, 'location_map': { 'burgerservicenummer': 'path', 'volgindicatie': 'body', }, 'collection_format_map': {} }, headers_map={ 'accept': [ 'application/json', 'application/hal+json', 'application/problem+json' ], 'content_type': ['application/json'] }, api_client=api_client, callable=__upsert_volgindicatie)