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)