# coding: utf-8

"""
    Kipartman

    Kipartman api specifications

    OpenAPI spec version: 1.0.0
    Contact: --
    Generated by: https://github.com/swagger-api/swagger-codegen.git
"""


from __future__ import absolute_import

import sys
import os
import re

# python 2 and python 3 compatibility library
from six import iteritems

from ..configuration import Configuration
from ..api_client import ApiClient


class DefaultApi(object):
    """
    NOTE: This class is auto generated by the swagger code generator program.
    Do not edit the class manually.
    Ref: https://github.com/swagger-api/swagger-codegen
    """

    def __init__(self, api_client=None):
        config = Configuration()
        if api_client:
            self.api_client = api_client
        else:
            if not config.api_client:
                config.api_client = ApiClient()
            self.api_client = config.api_client

    def add_distributor(self, distributor, **kwargs):
        """
        Creates a new distributor
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.add_distributor(distributor, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param DistributorNew distributor: Distributor to add (required)
        :return: Distributor
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.add_distributor_with_http_info(distributor, **kwargs)
        else:
            (data) = self.add_distributor_with_http_info(distributor, **kwargs)
            return data

    def add_distributor_with_http_info(self, distributor, **kwargs):
        """
        Creates a new distributor
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.add_distributor_with_http_info(distributor, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param DistributorNew distributor: Distributor to add (required)
        :return: Distributor
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['distributor']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method add_distributor" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'distributor' is set
        if ('distributor' not in params) or (params['distributor'] is None):
            raise ValueError("Missing the required parameter `distributor` when calling `add_distributor`")


        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'distributor' in params:
            body_params = params['distributor']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = []

        return self.api_client.call_api('/distributors', 'POST',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type='Distributor',
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    def add_footprint(self, footprint, **kwargs):
        """
        Creates a new footprint
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.add_footprint(footprint, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param FootprintNew footprint: Footprint to add (required)
        :return: Footprint
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.add_footprint_with_http_info(footprint, **kwargs)
        else:
            (data) = self.add_footprint_with_http_info(footprint, **kwargs)
            return data

    def add_footprint_with_http_info(self, footprint, **kwargs):
        """
        Creates a new footprint
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.add_footprint_with_http_info(footprint, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param FootprintNew footprint: Footprint to add (required)
        :return: Footprint
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['footprint']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method add_footprint" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'footprint' is set
        if ('footprint' not in params) or (params['footprint'] is None):
            raise ValueError("Missing the required parameter `footprint` when calling `add_footprint`")


        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'footprint' in params:
            body_params = params['footprint']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = []

        return self.api_client.call_api('/footprints', 'POST',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type='Footprint',
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    def add_footprints_category(self, category, **kwargs):
        """
        Creates a new footprint category
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.add_footprints_category(category, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param FootprintCategoryNew category: Category to add (required)
        :return: FootprintCategory
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.add_footprints_category_with_http_info(category, **kwargs)
        else:
            (data) = self.add_footprints_category_with_http_info(category, **kwargs)
            return data

    def add_footprints_category_with_http_info(self, category, **kwargs):
        """
        Creates a new footprint category
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.add_footprints_category_with_http_info(category, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param FootprintCategoryNew category: Category to add (required)
        :return: FootprintCategory
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['category']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method add_footprints_category" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'category' is set
        if ('category' not in params) or (params['category'] is None):
            raise ValueError("Missing the required parameter `category` when calling `add_footprints_category`")


        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'category' in params:
            body_params = params['category']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = []

        return self.api_client.call_api('/footprints/categories', 'POST',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type='FootprintCategory',
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    def add_manufacturer(self, manufacturer, **kwargs):
        """
        Creates a new manufacturer
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.add_manufacturer(manufacturer, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param ManufacturerNew manufacturer: Manufacturer to add (required)
        :return: Manufacturer
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.add_manufacturer_with_http_info(manufacturer, **kwargs)
        else:
            (data) = self.add_manufacturer_with_http_info(manufacturer, **kwargs)
            return data

    def add_manufacturer_with_http_info(self, manufacturer, **kwargs):
        """
        Creates a new manufacturer
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.add_manufacturer_with_http_info(manufacturer, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param ManufacturerNew manufacturer: Manufacturer to add (required)
        :return: Manufacturer
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['manufacturer']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method add_manufacturer" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'manufacturer' is set
        if ('manufacturer' not in params) or (params['manufacturer'] is None):
            raise ValueError("Missing the required parameter `manufacturer` when calling `add_manufacturer`")


        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'manufacturer' in params:
            body_params = params['manufacturer']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = []

        return self.api_client.call_api('/manufacturers', 'POST',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type='Manufacturer',
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    def add_model(self, model, **kwargs):
        """
        Creates a new model
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.add_model(model, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param ModelNew model: Model to add (required)
        :return: Model
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.add_model_with_http_info(model, **kwargs)
        else:
            (data) = self.add_model_with_http_info(model, **kwargs)
            return data

    def add_model_with_http_info(self, model, **kwargs):
        """
        Creates a new model
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.add_model_with_http_info(model, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param ModelNew model: Model to add (required)
        :return: Model
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['model']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method add_model" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'model' is set
        if ('model' not in params) or (params['model'] is None):
            raise ValueError("Missing the required parameter `model` when calling `add_model`")


        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'model' in params:
            body_params = params['model']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = []

        return self.api_client.call_api('/models', 'POST',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type='Model',
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    def add_models_category(self, category, **kwargs):
        """
        Creates a new model category
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.add_models_category(category, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param ModelCategoryNew category: Category to add (required)
        :return: ModelCategory
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.add_models_category_with_http_info(category, **kwargs)
        else:
            (data) = self.add_models_category_with_http_info(category, **kwargs)
            return data

    def add_models_category_with_http_info(self, category, **kwargs):
        """
        Creates a new model category
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.add_models_category_with_http_info(category, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param ModelCategoryNew category: Category to add (required)
        :return: ModelCategory
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['category']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method add_models_category" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'category' is set
        if ('category' not in params) or (params['category'] is None):
            raise ValueError("Missing the required parameter `category` when calling `add_models_category`")


        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'category' in params:
            body_params = params['category']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = []

        return self.api_client.call_api('/models/categories', 'POST',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type='ModelCategory',
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    def add_part(self, part, **kwargs):
        """
        Creates a new part
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.add_part(part, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param PartNew part: Part to add (required)
        :return: Part
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.add_part_with_http_info(part, **kwargs)
        else:
            (data) = self.add_part_with_http_info(part, **kwargs)
            return data

    def add_part_with_http_info(self, part, **kwargs):
        """
        Creates a new part
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.add_part_with_http_info(part, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param PartNew part: Part to add (required)
        :return: Part
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['part']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method add_part" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'part' is set
        if ('part' not in params) or (params['part'] is None):
            raise ValueError("Missing the required parameter `part` when calling `add_part`")


        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'part' in params:
            body_params = params['part']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = []

        return self.api_client.call_api('/parts', 'POST',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type='Part',
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    def add_parts_category(self, category, **kwargs):
        """
        Creates a new part category
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.add_parts_category(category, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param PartCategoryNew category: Category to add (required)
        :return: PartCategory
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.add_parts_category_with_http_info(category, **kwargs)
        else:
            (data) = self.add_parts_category_with_http_info(category, **kwargs)
            return data

    def add_parts_category_with_http_info(self, category, **kwargs):
        """
        Creates a new part category
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.add_parts_category_with_http_info(category, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param PartCategoryNew category: Category to add (required)
        :return: PartCategory
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['category']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method add_parts_category" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'category' is set
        if ('category' not in params) or (params['category'] is None):
            raise ValueError("Missing the required parameter `category` when calling `add_parts_category`")


        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'category' in params:
            body_params = params['category']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = []

        return self.api_client.call_api('/parts/categories', 'POST',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type='PartCategory',
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    def add_storage(self, storage, **kwargs):
        """
        Creates a new storage
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.add_storage(storage, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param StorageNew storage: Storage to add (required)
        :return: Storage
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.add_storage_with_http_info(storage, **kwargs)
        else:
            (data) = self.add_storage_with_http_info(storage, **kwargs)
            return data

    def add_storage_with_http_info(self, storage, **kwargs):
        """
        Creates a new storage
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.add_storage_with_http_info(storage, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param StorageNew storage: Storage to add (required)
        :return: Storage
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['storage']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method add_storage" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'storage' is set
        if ('storage' not in params) or (params['storage'] is None):
            raise ValueError("Missing the required parameter `storage` when calling `add_storage`")


        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'storage' in params:
            body_params = params['storage']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = []

        return self.api_client.call_api('/storages', 'POST',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type='Storage',
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    def add_storages_category(self, category, **kwargs):
        """
        Creates a new storage category
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.add_storages_category(category, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param StorageCategoryNew category: Category to add (required)
        :return: StorageCategory
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.add_storages_category_with_http_info(category, **kwargs)
        else:
            (data) = self.add_storages_category_with_http_info(category, **kwargs)
            return data

    def add_storages_category_with_http_info(self, category, **kwargs):
        """
        Creates a new storage category
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.add_storages_category_with_http_info(category, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param StorageCategoryNew category: Category to add (required)
        :return: StorageCategory
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['category']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method add_storages_category" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'category' is set
        if ('category' not in params) or (params['category'] is None):
            raise ValueError("Missing the required parameter `category` when calling `add_storages_category`")


        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'category' in params:
            body_params = params['category']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = []

        return self.api_client.call_api('/storages/categories', 'POST',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type='StorageCategory',
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    def add_upload_file(self, **kwargs):
        """
        Upload a file.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.add_upload_file(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param file upfile: The file to upload.
        :return: UploadFile
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.add_upload_file_with_http_info(**kwargs)
        else:
            (data) = self.add_upload_file_with_http_info(**kwargs)
            return data

    def add_upload_file_with_http_info(self, **kwargs):
        """
        Upload a file.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.add_upload_file_with_http_info(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param file upfile: The file to upload.
        :return: UploadFile
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['upfile']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method add_upload_file" % key
                )
            params[key] = val
        del params['kwargs']


        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}
        if 'upfile' in params:
            local_var_files['upfile'] = params['upfile']

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['multipart/form-data'])

        # Authentication setting
        auth_settings = []

        return self.api_client.call_api('/upload', 'POST',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type='UploadFile',
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    def delete_distributor(self, distributor_id, **kwargs):
        """
        Delete distributor
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.delete_distributor(distributor_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int distributor_id: Distributor id (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.delete_distributor_with_http_info(distributor_id, **kwargs)
        else:
            (data) = self.delete_distributor_with_http_info(distributor_id, **kwargs)
            return data

    def delete_distributor_with_http_info(self, distributor_id, **kwargs):
        """
        Delete distributor
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.delete_distributor_with_http_info(distributor_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int distributor_id: Distributor id (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['distributor_id']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method delete_distributor" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'distributor_id' is set
        if ('distributor_id' not in params) or (params['distributor_id'] is None):
            raise ValueError("Missing the required parameter `distributor_id` when calling `delete_distributor`")


        collection_formats = {}

        path_params = {}
        if 'distributor_id' in params:
            path_params['distributor_id'] = params['distributor_id']

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = []

        return self.api_client.call_api('/distributors/{distributor_id}', 'DELETE',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type=None,
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    def delete_footprint(self, footprint_id, **kwargs):
        """
        Delete footprint
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.delete_footprint(footprint_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int footprint_id: Footprint id (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.delete_footprint_with_http_info(footprint_id, **kwargs)
        else:
            (data) = self.delete_footprint_with_http_info(footprint_id, **kwargs)
            return data

    def delete_footprint_with_http_info(self, footprint_id, **kwargs):
        """
        Delete footprint
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.delete_footprint_with_http_info(footprint_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int footprint_id: Footprint id (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['footprint_id']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method delete_footprint" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'footprint_id' is set
        if ('footprint_id' not in params) or (params['footprint_id'] is None):
            raise ValueError("Missing the required parameter `footprint_id` when calling `delete_footprint`")


        collection_formats = {}

        path_params = {}
        if 'footprint_id' in params:
            path_params['footprint_id'] = params['footprint_id']

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = []

        return self.api_client.call_api('/footprints/{footprint_id}', 'DELETE',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type=None,
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    def delete_footprints_category(self, category_id, **kwargs):
        """
        Delete footprint category
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.delete_footprints_category(category_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int category_id: Category id (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.delete_footprints_category_with_http_info(category_id, **kwargs)
        else:
            (data) = self.delete_footprints_category_with_http_info(category_id, **kwargs)
            return data

    def delete_footprints_category_with_http_info(self, category_id, **kwargs):
        """
        Delete footprint category
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.delete_footprints_category_with_http_info(category_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int category_id: Category id (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['category_id']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method delete_footprints_category" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'category_id' is set
        if ('category_id' not in params) or (params['category_id'] is None):
            raise ValueError("Missing the required parameter `category_id` when calling `delete_footprints_category`")


        collection_formats = {}

        path_params = {}
        if 'category_id' in params:
            path_params['category_id'] = params['category_id']

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = []

        return self.api_client.call_api('/footprints/categories/{category_id}', 'DELETE',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type=None,
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    def delete_manufacturer(self, manufacturer_id, **kwargs):
        """
        Delete manufacturer
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.delete_manufacturer(manufacturer_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int manufacturer_id: Manufacturer id (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.delete_manufacturer_with_http_info(manufacturer_id, **kwargs)
        else:
            (data) = self.delete_manufacturer_with_http_info(manufacturer_id, **kwargs)
            return data

    def delete_manufacturer_with_http_info(self, manufacturer_id, **kwargs):
        """
        Delete manufacturer
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.delete_manufacturer_with_http_info(manufacturer_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int manufacturer_id: Manufacturer id (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['manufacturer_id']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method delete_manufacturer" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'manufacturer_id' is set
        if ('manufacturer_id' not in params) or (params['manufacturer_id'] is None):
            raise ValueError("Missing the required parameter `manufacturer_id` when calling `delete_manufacturer`")


        collection_formats = {}

        path_params = {}
        if 'manufacturer_id' in params:
            path_params['manufacturer_id'] = params['manufacturer_id']

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = []

        return self.api_client.call_api('/manufacturers/{manufacturer_id}', 'DELETE',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type=None,
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    def delete_model(self, model_id, **kwargs):
        """
        Delete model
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.delete_model(model_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int model_id: Footprint id (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.delete_model_with_http_info(model_id, **kwargs)
        else:
            (data) = self.delete_model_with_http_info(model_id, **kwargs)
            return data

    def delete_model_with_http_info(self, model_id, **kwargs):
        """
        Delete model
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.delete_model_with_http_info(model_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int model_id: Footprint id (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['model_id']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method delete_model" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'model_id' is set
        if ('model_id' not in params) or (params['model_id'] is None):
            raise ValueError("Missing the required parameter `model_id` when calling `delete_model`")


        collection_formats = {}

        path_params = {}
        if 'model_id' in params:
            path_params['model_id'] = params['model_id']

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = []

        return self.api_client.call_api('/models/{model_id}', 'DELETE',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type=None,
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    def delete_models_category(self, category_id, **kwargs):
        """
        Delete model category
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.delete_models_category(category_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int category_id: Category id (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.delete_models_category_with_http_info(category_id, **kwargs)
        else:
            (data) = self.delete_models_category_with_http_info(category_id, **kwargs)
            return data

    def delete_models_category_with_http_info(self, category_id, **kwargs):
        """
        Delete model category
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.delete_models_category_with_http_info(category_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int category_id: Category id (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['category_id']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method delete_models_category" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'category_id' is set
        if ('category_id' not in params) or (params['category_id'] is None):
            raise ValueError("Missing the required parameter `category_id` when calling `delete_models_category`")


        collection_formats = {}

        path_params = {}
        if 'category_id' in params:
            path_params['category_id'] = params['category_id']

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = []

        return self.api_client.call_api('/models/categories/{category_id}', 'DELETE',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type=None,
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    def delete_part(self, part_id, **kwargs):
        """
        Delete part
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.delete_part(part_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int part_id: Part id (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.delete_part_with_http_info(part_id, **kwargs)
        else:
            (data) = self.delete_part_with_http_info(part_id, **kwargs)
            return data

    def delete_part_with_http_info(self, part_id, **kwargs):
        """
        Delete part
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.delete_part_with_http_info(part_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int part_id: Part id (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['part_id']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method delete_part" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'part_id' is set
        if ('part_id' not in params) or (params['part_id'] is None):
            raise ValueError("Missing the required parameter `part_id` when calling `delete_part`")


        collection_formats = {}

        path_params = {}
        if 'part_id' in params:
            path_params['part_id'] = params['part_id']

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = []

        return self.api_client.call_api('/parts/{part_id}', 'DELETE',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type=None,
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    def delete_parts_category(self, category_id, **kwargs):
        """
        Delete part category
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.delete_parts_category(category_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int category_id: Category id (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.delete_parts_category_with_http_info(category_id, **kwargs)
        else:
            (data) = self.delete_parts_category_with_http_info(category_id, **kwargs)
            return data

    def delete_parts_category_with_http_info(self, category_id, **kwargs):
        """
        Delete part category
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.delete_parts_category_with_http_info(category_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int category_id: Category id (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['category_id']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method delete_parts_category" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'category_id' is set
        if ('category_id' not in params) or (params['category_id'] is None):
            raise ValueError("Missing the required parameter `category_id` when calling `delete_parts_category`")


        collection_formats = {}

        path_params = {}
        if 'category_id' in params:
            path_params['category_id'] = params['category_id']

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = []

        return self.api_client.call_api('/parts/categories/{category_id}', 'DELETE',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type=None,
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    def delete_storage(self, storage_id, **kwargs):
        """
        Delete storage
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.delete_storage(storage_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int storage_id: Storage id (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.delete_storage_with_http_info(storage_id, **kwargs)
        else:
            (data) = self.delete_storage_with_http_info(storage_id, **kwargs)
            return data

    def delete_storage_with_http_info(self, storage_id, **kwargs):
        """
        Delete storage
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.delete_storage_with_http_info(storage_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int storage_id: Storage id (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['storage_id']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method delete_storage" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'storage_id' is set
        if ('storage_id' not in params) or (params['storage_id'] is None):
            raise ValueError("Missing the required parameter `storage_id` when calling `delete_storage`")


        collection_formats = {}

        path_params = {}
        if 'storage_id' in params:
            path_params['storage_id'] = params['storage_id']

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = []

        return self.api_client.call_api('/storages/{storage_id}', 'DELETE',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type=None,
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    def delete_storages_category(self, category_id, **kwargs):
        """
        Delete storage category
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.delete_storages_category(category_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int category_id: Category id (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.delete_storages_category_with_http_info(category_id, **kwargs)
        else:
            (data) = self.delete_storages_category_with_http_info(category_id, **kwargs)
            return data

    def delete_storages_category_with_http_info(self, category_id, **kwargs):
        """
        Delete storage category
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.delete_storages_category_with_http_info(category_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int category_id: Category id (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['category_id']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method delete_storages_category" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'category_id' is set
        if ('category_id' not in params) or (params['category_id'] is None):
            raise ValueError("Missing the required parameter `category_id` when calling `delete_storages_category`")


        collection_formats = {}

        path_params = {}
        if 'category_id' in params:
            path_params['category_id'] = params['category_id']

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = []

        return self.api_client.call_api('/storages/categories/{category_id}', 'DELETE',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type=None,
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    def find_distributor(self, distributor_id, **kwargs):
        """
        Return a distributor
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.find_distributor(distributor_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int distributor_id: Distributor id (required)
        :return: Distributor
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.find_distributor_with_http_info(distributor_id, **kwargs)
        else:
            (data) = self.find_distributor_with_http_info(distributor_id, **kwargs)
            return data

    def find_distributor_with_http_info(self, distributor_id, **kwargs):
        """
        Return a distributor
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.find_distributor_with_http_info(distributor_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int distributor_id: Distributor id (required)
        :return: Distributor
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['distributor_id']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method find_distributor" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'distributor_id' is set
        if ('distributor_id' not in params) or (params['distributor_id'] is None):
            raise ValueError("Missing the required parameter `distributor_id` when calling `find_distributor`")


        collection_formats = {}

        path_params = {}
        if 'distributor_id' in params:
            path_params['distributor_id'] = params['distributor_id']

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = []

        return self.api_client.call_api('/distributors/{distributor_id}', 'GET',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type='Distributor',
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    def find_distributors(self, **kwargs):
        """
        Return all distributors
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.find_distributors(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str name: Search distributors matching name
        :return: list[Distributor]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.find_distributors_with_http_info(**kwargs)
        else:
            (data) = self.find_distributors_with_http_info(**kwargs)
            return data

    def find_distributors_with_http_info(self, **kwargs):
        """
        Return all distributors
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.find_distributors_with_http_info(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str name: Search distributors matching name
        :return: list[Distributor]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method find_distributors" % key
                )
            params[key] = val
        del params['kwargs']


        collection_formats = {}

        path_params = {}

        query_params = []
        if 'name' in params:
            query_params.append(('name', params['name']))

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = []

        return self.api_client.call_api('/distributors', 'GET',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type='list[Distributor]',
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    def find_footprint(self, footprint_id, **kwargs):
        """
        Return a footprint
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.find_footprint(footprint_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int footprint_id: Footprint id (required)
        :return: Footprint
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.find_footprint_with_http_info(footprint_id, **kwargs)
        else:
            (data) = self.find_footprint_with_http_info(footprint_id, **kwargs)
            return data

    def find_footprint_with_http_info(self, footprint_id, **kwargs):
        """
        Return a footprint
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.find_footprint_with_http_info(footprint_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int footprint_id: Footprint id (required)
        :return: Footprint
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['footprint_id']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method find_footprint" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'footprint_id' is set
        if ('footprint_id' not in params) or (params['footprint_id'] is None):
            raise ValueError("Missing the required parameter `footprint_id` when calling `find_footprint`")


        collection_formats = {}

        path_params = {}
        if 'footprint_id' in params:
            path_params['footprint_id'] = params['footprint_id']

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = []

        return self.api_client.call_api('/footprints/{footprint_id}', 'GET',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type='Footprint',
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    def find_footprints(self, **kwargs):
        """
        Return all footprints
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.find_footprints(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int category: Filter by category
        :param str search: Search for footprint matching pattern
        :return: list[Footprint]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.find_footprints_with_http_info(**kwargs)
        else:
            (data) = self.find_footprints_with_http_info(**kwargs)
            return data

    def find_footprints_with_http_info(self, **kwargs):
        """
        Return all footprints
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.find_footprints_with_http_info(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int category: Filter by category
        :param str search: Search for footprint matching pattern
        :return: list[Footprint]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['category', 'search']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method find_footprints" % key
                )
            params[key] = val
        del params['kwargs']


        collection_formats = {}

        path_params = {}

        query_params = []
        if 'category' in params:
            query_params.append(('category', params['category']))
        if 'search' in params:
            query_params.append(('search', params['search']))

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = []

        return self.api_client.call_api('/footprints', 'GET',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type='list[Footprint]',
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    def find_footprints_categories(self, **kwargs):
        """
        Return all categories for footprints
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.find_footprints_categories(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :return: list[FootprintCategory]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.find_footprints_categories_with_http_info(**kwargs)
        else:
            (data) = self.find_footprints_categories_with_http_info(**kwargs)
            return data

    def find_footprints_categories_with_http_info(self, **kwargs):
        """
        Return all categories for footprints
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.find_footprints_categories_with_http_info(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :return: list[FootprintCategory]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = []
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method find_footprints_categories" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = []

        return self.api_client.call_api('/footprints/categories', 'GET',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type='list[FootprintCategory]',
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    def find_footprints_category(self, category_id, **kwargs):
        """
        Return a footprint category
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.find_footprints_category(category_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int category_id: Category id (required)
        :return: FootprintCategory
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.find_footprints_category_with_http_info(category_id, **kwargs)
        else:
            (data) = self.find_footprints_category_with_http_info(category_id, **kwargs)
            return data

    def find_footprints_category_with_http_info(self, category_id, **kwargs):
        """
        Return a footprint category
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.find_footprints_category_with_http_info(category_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int category_id: Category id (required)
        :return: FootprintCategory
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['category_id']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method find_footprints_category" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'category_id' is set
        if ('category_id' not in params) or (params['category_id'] is None):
            raise ValueError("Missing the required parameter `category_id` when calling `find_footprints_category`")


        collection_formats = {}

        path_params = {}
        if 'category_id' in params:
            path_params['category_id'] = params['category_id']

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = []

        return self.api_client.call_api('/footprints/categories/{category_id}', 'GET',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type='FootprintCategory',
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    def find_manufacturer(self, manufacturer_id, **kwargs):
        """
        Return a manufacturer
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.find_manufacturer(manufacturer_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int manufacturer_id: Manufacturer id (required)
        :return: Manufacturer
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.find_manufacturer_with_http_info(manufacturer_id, **kwargs)
        else:
            (data) = self.find_manufacturer_with_http_info(manufacturer_id, **kwargs)
            return data

    def find_manufacturer_with_http_info(self, manufacturer_id, **kwargs):
        """
        Return a manufacturer
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.find_manufacturer_with_http_info(manufacturer_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int manufacturer_id: Manufacturer id (required)
        :return: Manufacturer
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['manufacturer_id']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method find_manufacturer" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'manufacturer_id' is set
        if ('manufacturer_id' not in params) or (params['manufacturer_id'] is None):
            raise ValueError("Missing the required parameter `manufacturer_id` when calling `find_manufacturer`")


        collection_formats = {}

        path_params = {}
        if 'manufacturer_id' in params:
            path_params['manufacturer_id'] = params['manufacturer_id']

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = []

        return self.api_client.call_api('/manufacturers/{manufacturer_id}', 'GET',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type='Manufacturer',
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    def find_manufacturers(self, **kwargs):
        """
        Return all manufacturers
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.find_manufacturers(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str name: Search manufacturers matching name
        :return: list[Manufacturer]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.find_manufacturers_with_http_info(**kwargs)
        else:
            (data) = self.find_manufacturers_with_http_info(**kwargs)
            return data

    def find_manufacturers_with_http_info(self, **kwargs):
        """
        Return all manufacturers
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.find_manufacturers_with_http_info(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str name: Search manufacturers matching name
        :return: list[Manufacturer]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method find_manufacturers" % key
                )
            params[key] = val
        del params['kwargs']


        collection_formats = {}

        path_params = {}

        query_params = []
        if 'name' in params:
            query_params.append(('name', params['name']))

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = []

        return self.api_client.call_api('/manufacturers', 'GET',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type='list[Manufacturer]',
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    def find_model(self, model_id, **kwargs):
        """
        Return a model
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.find_model(model_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int model_id: Footprint id (required)
        :return: Model
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.find_model_with_http_info(model_id, **kwargs)
        else:
            (data) = self.find_model_with_http_info(model_id, **kwargs)
            return data

    def find_model_with_http_info(self, model_id, **kwargs):
        """
        Return a model
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.find_model_with_http_info(model_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int model_id: Footprint id (required)
        :return: Model
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['model_id']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method find_model" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'model_id' is set
        if ('model_id' not in params) or (params['model_id'] is None):
            raise ValueError("Missing the required parameter `model_id` when calling `find_model`")


        collection_formats = {}

        path_params = {}
        if 'model_id' in params:
            path_params['model_id'] = params['model_id']

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = []

        return self.api_client.call_api('/models/{model_id}', 'GET',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type='Model',
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    def find_models(self, **kwargs):
        """
        Return all models
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.find_models(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int category: Filter by category
        :param str search: Search for model matching pattern
        :return: list[Model]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.find_models_with_http_info(**kwargs)
        else:
            (data) = self.find_models_with_http_info(**kwargs)
            return data

    def find_models_with_http_info(self, **kwargs):
        """
        Return all models
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.find_models_with_http_info(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int category: Filter by category
        :param str search: Search for model matching pattern
        :return: list[Model]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['category', 'search']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method find_models" % key
                )
            params[key] = val
        del params['kwargs']


        collection_formats = {}

        path_params = {}

        query_params = []
        if 'category' in params:
            query_params.append(('category', params['category']))
        if 'search' in params:
            query_params.append(('search', params['search']))

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = []

        return self.api_client.call_api('/models', 'GET',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type='list[Model]',
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    def find_models_categories(self, **kwargs):
        """
        Return all categories for models
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.find_models_categories(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :return: list[ModelCategory]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.find_models_categories_with_http_info(**kwargs)
        else:
            (data) = self.find_models_categories_with_http_info(**kwargs)
            return data

    def find_models_categories_with_http_info(self, **kwargs):
        """
        Return all categories for models
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.find_models_categories_with_http_info(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :return: list[ModelCategory]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = []
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method find_models_categories" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = []

        return self.api_client.call_api('/models/categories', 'GET',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type='list[ModelCategory]',
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    def find_models_category(self, category_id, **kwargs):
        """
        Return a model category
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.find_models_category(category_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int category_id: Category id (required)
        :return: ModelCategory
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.find_models_category_with_http_info(category_id, **kwargs)
        else:
            (data) = self.find_models_category_with_http_info(category_id, **kwargs)
            return data

    def find_models_category_with_http_info(self, category_id, **kwargs):
        """
        Return a model category
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.find_models_category_with_http_info(category_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int category_id: Category id (required)
        :return: ModelCategory
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['category_id']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method find_models_category" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'category_id' is set
        if ('category_id' not in params) or (params['category_id'] is None):
            raise ValueError("Missing the required parameter `category_id` when calling `find_models_category`")


        collection_formats = {}

        path_params = {}
        if 'category_id' in params:
            path_params['category_id'] = params['category_id']

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = []

        return self.api_client.call_api('/models/categories/{category_id}', 'GET',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type='ModelCategory',
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    def find_part(self, part_id, **kwargs):
        """
        Return a part
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.find_part(part_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int part_id: Part id (required)
        :param bool with_offers: Include offers in answer
        :param bool with_parameters: Include parameters in answer
        :param bool with_childs: Include childs in answer
        :param bool with_distributors: Include distributors in answer
        :param bool with_manufacturers: Include manufacturers in answer
        :param bool with_storages: Include storages in answer
        :param bool with_attachements: Include attachements in answer
        :return: Part
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.find_part_with_http_info(part_id, **kwargs)
        else:
            (data) = self.find_part_with_http_info(part_id, **kwargs)
            return data

    def find_part_with_http_info(self, part_id, **kwargs):
        """
        Return a part
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.find_part_with_http_info(part_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int part_id: Part id (required)
        :param bool with_offers: Include offers in answer
        :param bool with_parameters: Include parameters in answer
        :param bool with_childs: Include childs in answer
        :param bool with_distributors: Include distributors in answer
        :param bool with_manufacturers: Include manufacturers in answer
        :param bool with_storages: Include storages in answer
        :param bool with_attachements: Include attachements in answer
        :return: Part
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['part_id', 'with_offers', 'with_parameters', 'with_childs', 'with_distributors', 'with_manufacturers', 'with_storages', 'with_attachements']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method find_part" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'part_id' is set
        if ('part_id' not in params) or (params['part_id'] is None):
            raise ValueError("Missing the required parameter `part_id` when calling `find_part`")


        collection_formats = {}

        path_params = {}
        if 'part_id' in params:
            path_params['part_id'] = params['part_id']

        query_params = []
        if 'with_offers' in params:
            query_params.append(('with_offers', params['with_offers']))
        if 'with_parameters' in params:
            query_params.append(('with_parameters', params['with_parameters']))
        if 'with_childs' in params:
            query_params.append(('with_childs', params['with_childs']))
        if 'with_distributors' in params:
            query_params.append(('with_distributors', params['with_distributors']))
        if 'with_manufacturers' in params:
            query_params.append(('with_manufacturers', params['with_manufacturers']))
        if 'with_storages' in params:
            query_params.append(('with_storages', params['with_storages']))
        if 'with_attachements' in params:
            query_params.append(('with_attachements', params['with_attachements']))

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = []

        return self.api_client.call_api('/parts/{part_id}', 'GET',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type='Part',
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    def find_parts(self, **kwargs):
        """
        Return all parts
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.find_parts(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int category: Filter by category
        :param int storage: Filter by storage
        :param bool with_offers: Include offers in answer
        :param bool with_parameters: Include parameters in answer
        :param bool with_childs: Include childs in answer
        :param bool with_distributors: Include distributors in answer
        :param bool with_manufacturers: Include manufacturers in answer
        :param bool with_storages: Include storages in answer
        :param bool with_attachements: Include attachements in answer
        :param str search: Search for parts matching pattern
        :return: list[Part]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.find_parts_with_http_info(**kwargs)
        else:
            (data) = self.find_parts_with_http_info(**kwargs)
            return data

    def find_parts_with_http_info(self, **kwargs):
        """
        Return all parts
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.find_parts_with_http_info(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int category: Filter by category
        :param int storage: Filter by storage
        :param bool with_offers: Include offers in answer
        :param bool with_parameters: Include parameters in answer
        :param bool with_childs: Include childs in answer
        :param bool with_distributors: Include distributors in answer
        :param bool with_manufacturers: Include manufacturers in answer
        :param bool with_storages: Include storages in answer
        :param bool with_attachements: Include attachements in answer
        :param str search: Search for parts matching pattern
        :return: list[Part]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['category', 'storage', 'with_offers', 'with_parameters', 'with_childs', 'with_distributors', 'with_manufacturers', 'with_storages', 'with_attachements', 'search']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method find_parts" % key
                )
            params[key] = val
        del params['kwargs']


        collection_formats = {}

        path_params = {}

        query_params = []
        if 'category' in params:
            query_params.append(('category', params['category']))
        if 'storage' in params:
            query_params.append(('storage', params['storage']))
        if 'with_offers' in params:
            query_params.append(('with_offers', params['with_offers']))
        if 'with_parameters' in params:
            query_params.append(('with_parameters', params['with_parameters']))
        if 'with_childs' in params:
            query_params.append(('with_childs', params['with_childs']))
        if 'with_distributors' in params:
            query_params.append(('with_distributors', params['with_distributors']))
        if 'with_manufacturers' in params:
            query_params.append(('with_manufacturers', params['with_manufacturers']))
        if 'with_storages' in params:
            query_params.append(('with_storages', params['with_storages']))
        if 'with_attachements' in params:
            query_params.append(('with_attachements', params['with_attachements']))
        if 'search' in params:
            query_params.append(('search', params['search']))

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = []

        return self.api_client.call_api('/parts', 'GET',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type='list[Part]',
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    def find_parts_categories(self, **kwargs):
        """
        Return all categories for parts
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.find_parts_categories(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :return: list[PartCategory]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.find_parts_categories_with_http_info(**kwargs)
        else:
            (data) = self.find_parts_categories_with_http_info(**kwargs)
            return data

    def find_parts_categories_with_http_info(self, **kwargs):
        """
        Return all categories for parts
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.find_parts_categories_with_http_info(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :return: list[PartCategory]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = []
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method find_parts_categories" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = []

        return self.api_client.call_api('/parts/categories', 'GET',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type='list[PartCategory]',
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    def find_parts_category(self, category_id, **kwargs):
        """
        Return a part category
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.find_parts_category(category_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int category_id: Category id (required)
        :return: PartCategory
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.find_parts_category_with_http_info(category_id, **kwargs)
        else:
            (data) = self.find_parts_category_with_http_info(category_id, **kwargs)
            return data

    def find_parts_category_with_http_info(self, category_id, **kwargs):
        """
        Return a part category
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.find_parts_category_with_http_info(category_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int category_id: Category id (required)
        :return: PartCategory
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['category_id']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method find_parts_category" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'category_id' is set
        if ('category_id' not in params) or (params['category_id'] is None):
            raise ValueError("Missing the required parameter `category_id` when calling `find_parts_category`")


        collection_formats = {}

        path_params = {}
        if 'category_id' in params:
            path_params['category_id'] = params['category_id']

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = []

        return self.api_client.call_api('/parts/categories/{category_id}', 'GET',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type='PartCategory',
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    def find_storage(self, storage_id, **kwargs):
        """
        Return a storage
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.find_storage(storage_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int storage_id: Storage id (required)
        :return: Storage
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.find_storage_with_http_info(storage_id, **kwargs)
        else:
            (data) = self.find_storage_with_http_info(storage_id, **kwargs)
            return data

    def find_storage_with_http_info(self, storage_id, **kwargs):
        """
        Return a storage
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.find_storage_with_http_info(storage_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int storage_id: Storage id (required)
        :return: Storage
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['storage_id']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method find_storage" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'storage_id' is set
        if ('storage_id' not in params) or (params['storage_id'] is None):
            raise ValueError("Missing the required parameter `storage_id` when calling `find_storage`")


        collection_formats = {}

        path_params = {}
        if 'storage_id' in params:
            path_params['storage_id'] = params['storage_id']

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = []

        return self.api_client.call_api('/storages/{storage_id}', 'GET',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type='Storage',
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    def find_storages(self, **kwargs):
        """
        Return all storages
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.find_storages(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int category: Filter by category
        :param str search: Search for storage matching pattern
        :return: list[Storage]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.find_storages_with_http_info(**kwargs)
        else:
            (data) = self.find_storages_with_http_info(**kwargs)
            return data

    def find_storages_with_http_info(self, **kwargs):
        """
        Return all storages
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.find_storages_with_http_info(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int category: Filter by category
        :param str search: Search for storage matching pattern
        :return: list[Storage]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['category', 'search']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method find_storages" % key
                )
            params[key] = val
        del params['kwargs']


        collection_formats = {}

        path_params = {}

        query_params = []
        if 'category' in params:
            query_params.append(('category', params['category']))
        if 'search' in params:
            query_params.append(('search', params['search']))

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = []

        return self.api_client.call_api('/storages', 'GET',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type='list[Storage]',
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    def find_storages_categories(self, **kwargs):
        """
        Return all categories for storages
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.find_storages_categories(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :return: list[StorageCategory]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.find_storages_categories_with_http_info(**kwargs)
        else:
            (data) = self.find_storages_categories_with_http_info(**kwargs)
            return data

    def find_storages_categories_with_http_info(self, **kwargs):
        """
        Return all categories for storages
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.find_storages_categories_with_http_info(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :return: list[StorageCategory]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = []
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method find_storages_categories" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = []

        return self.api_client.call_api('/storages/categories', 'GET',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type='list[StorageCategory]',
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    def find_storages_category(self, category_id, **kwargs):
        """
        Return a storage category
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.find_storages_category(category_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int category_id: Category id (required)
        :return: StorageCategory
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.find_storages_category_with_http_info(category_id, **kwargs)
        else:
            (data) = self.find_storages_category_with_http_info(category_id, **kwargs)
            return data

    def find_storages_category_with_http_info(self, category_id, **kwargs):
        """
        Return a storage category
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.find_storages_category_with_http_info(category_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int category_id: Category id (required)
        :return: StorageCategory
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['category_id']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method find_storages_category" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'category_id' is set
        if ('category_id' not in params) or (params['category_id'] is None):
            raise ValueError("Missing the required parameter `category_id` when calling `find_storages_category`")


        collection_formats = {}

        path_params = {}
        if 'category_id' in params:
            path_params['category_id'] = params['category_id']

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = []

        return self.api_client.call_api('/storages/categories/{category_id}', 'GET',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type='StorageCategory',
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    def find_unit(self, unit_id, **kwargs):
        """
        Return a unit
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.find_unit(unit_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int unit_id: Unit id (required)
        :return: Unit
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.find_unit_with_http_info(unit_id, **kwargs)
        else:
            (data) = self.find_unit_with_http_info(unit_id, **kwargs)
            return data

    def find_unit_with_http_info(self, unit_id, **kwargs):
        """
        Return a unit
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.find_unit_with_http_info(unit_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int unit_id: Unit id (required)
        :return: Unit
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['unit_id']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method find_unit" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'unit_id' is set
        if ('unit_id' not in params) or (params['unit_id'] is None):
            raise ValueError("Missing the required parameter `unit_id` when calling `find_unit`")


        collection_formats = {}

        path_params = {}
        if 'unit_id' in params:
            path_params['unit_id'] = params['unit_id']

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = []

        return self.api_client.call_api('/units/{unit_id}', 'GET',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type='Unit',
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    def find_unit_prefix(self, unit_prefix_id, **kwargs):
        """
        Return a unit prefixes
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.find_unit_prefix(unit_prefix_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int unit_prefix_id: Unit prefix id (required)
        :return: UnitPrefix
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.find_unit_prefix_with_http_info(unit_prefix_id, **kwargs)
        else:
            (data) = self.find_unit_prefix_with_http_info(unit_prefix_id, **kwargs)
            return data

    def find_unit_prefix_with_http_info(self, unit_prefix_id, **kwargs):
        """
        Return a unit prefixes
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.find_unit_prefix_with_http_info(unit_prefix_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int unit_prefix_id: Unit prefix id (required)
        :return: UnitPrefix
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['unit_prefix_id']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method find_unit_prefix" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'unit_prefix_id' is set
        if ('unit_prefix_id' not in params) or (params['unit_prefix_id'] is None):
            raise ValueError("Missing the required parameter `unit_prefix_id` when calling `find_unit_prefix`")


        collection_formats = {}

        path_params = {}
        if 'unit_prefix_id' in params:
            path_params['unit_prefix_id'] = params['unit_prefix_id']

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = []

        return self.api_client.call_api('/unitprefixes/{unit_prefix_id}', 'GET',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type='UnitPrefix',
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    def find_unit_prefixes(self, **kwargs):
        """
        Return list of unit prefixes
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.find_unit_prefixes(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str symbol: Search prefix symbol
        :return: list[UnitPrefix]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.find_unit_prefixes_with_http_info(**kwargs)
        else:
            (data) = self.find_unit_prefixes_with_http_info(**kwargs)
            return data

    def find_unit_prefixes_with_http_info(self, **kwargs):
        """
        Return list of unit prefixes
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.find_unit_prefixes_with_http_info(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str symbol: Search prefix symbol
        :return: list[UnitPrefix]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['symbol']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method find_unit_prefixes" % key
                )
            params[key] = val
        del params['kwargs']


        collection_formats = {}

        path_params = {}

        query_params = []
        if 'symbol' in params:
            query_params.append(('symbol', params['symbol']))

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = []

        return self.api_client.call_api('/unitprefixes', 'GET',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type='list[UnitPrefix]',
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    def find_units(self, **kwargs):
        """
        Return list of units
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.find_units(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str symbol: Search symbol
        :return: list[Unit]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.find_units_with_http_info(**kwargs)
        else:
            (data) = self.find_units_with_http_info(**kwargs)
            return data

    def find_units_with_http_info(self, **kwargs):
        """
        Return list of units
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.find_units_with_http_info(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str symbol: Search symbol
        :return: list[Unit]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['symbol']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method find_units" % key
                )
            params[key] = val
        del params['kwargs']


        collection_formats = {}

        path_params = {}

        query_params = []
        if 'symbol' in params:
            query_params.append(('symbol', params['symbol']))

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = []

        return self.api_client.call_api('/units', 'GET',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type='list[Unit]',
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    def update_distributor(self, distributor_id, category, **kwargs):
        """
        Update a distributor
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.update_distributor(distributor_id, category, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int distributor_id: Distributor id (required)
        :param DistributorNew category: Distributor to update (required)
        :return: Distributor
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.update_distributor_with_http_info(distributor_id, category, **kwargs)
        else:
            (data) = self.update_distributor_with_http_info(distributor_id, category, **kwargs)
            return data

    def update_distributor_with_http_info(self, distributor_id, category, **kwargs):
        """
        Update a distributor
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.update_distributor_with_http_info(distributor_id, category, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int distributor_id: Distributor id (required)
        :param DistributorNew category: Distributor to update (required)
        :return: Distributor
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['distributor_id', 'category']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method update_distributor" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'distributor_id' is set
        if ('distributor_id' not in params) or (params['distributor_id'] is None):
            raise ValueError("Missing the required parameter `distributor_id` when calling `update_distributor`")
        # verify the required parameter 'category' is set
        if ('category' not in params) or (params['category'] is None):
            raise ValueError("Missing the required parameter `category` when calling `update_distributor`")


        collection_formats = {}

        path_params = {}
        if 'distributor_id' in params:
            path_params['distributor_id'] = params['distributor_id']

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'category' in params:
            body_params = params['category']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = []

        return self.api_client.call_api('/distributors/{distributor_id}', 'PUT',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type='Distributor',
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    def update_footprint(self, footprint_id, footprint, **kwargs):
        """
        Update footprint
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.update_footprint(footprint_id, footprint, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int footprint_id: Footprint id (required)
        :param FootprintNew footprint: Footprint to update (required)
        :return: Footprint
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.update_footprint_with_http_info(footprint_id, footprint, **kwargs)
        else:
            (data) = self.update_footprint_with_http_info(footprint_id, footprint, **kwargs)
            return data

    def update_footprint_with_http_info(self, footprint_id, footprint, **kwargs):
        """
        Update footprint
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.update_footprint_with_http_info(footprint_id, footprint, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int footprint_id: Footprint id (required)
        :param FootprintNew footprint: Footprint to update (required)
        :return: Footprint
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['footprint_id', 'footprint']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method update_footprint" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'footprint_id' is set
        if ('footprint_id' not in params) or (params['footprint_id'] is None):
            raise ValueError("Missing the required parameter `footprint_id` when calling `update_footprint`")
        # verify the required parameter 'footprint' is set
        if ('footprint' not in params) or (params['footprint'] is None):
            raise ValueError("Missing the required parameter `footprint` when calling `update_footprint`")


        collection_formats = {}

        path_params = {}
        if 'footprint_id' in params:
            path_params['footprint_id'] = params['footprint_id']

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'footprint' in params:
            body_params = params['footprint']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = []

        return self.api_client.call_api('/footprints/{footprint_id}', 'PUT',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type='Footprint',
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    def update_footprints_category(self, category_id, category, **kwargs):
        """
        Update footprint category
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.update_footprints_category(category_id, category, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int category_id: Category id (required)
        :param FootprintCategoryNew category: Category to update (required)
        :return: FootprintCategory
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.update_footprints_category_with_http_info(category_id, category, **kwargs)
        else:
            (data) = self.update_footprints_category_with_http_info(category_id, category, **kwargs)
            return data

    def update_footprints_category_with_http_info(self, category_id, category, **kwargs):
        """
        Update footprint category
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.update_footprints_category_with_http_info(category_id, category, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int category_id: Category id (required)
        :param FootprintCategoryNew category: Category to update (required)
        :return: FootprintCategory
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['category_id', 'category']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method update_footprints_category" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'category_id' is set
        if ('category_id' not in params) or (params['category_id'] is None):
            raise ValueError("Missing the required parameter `category_id` when calling `update_footprints_category`")
        # verify the required parameter 'category' is set
        if ('category' not in params) or (params['category'] is None):
            raise ValueError("Missing the required parameter `category` when calling `update_footprints_category`")


        collection_formats = {}

        path_params = {}
        if 'category_id' in params:
            path_params['category_id'] = params['category_id']

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'category' in params:
            body_params = params['category']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = []

        return self.api_client.call_api('/footprints/categories/{category_id}', 'PUT',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type='FootprintCategory',
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    def update_manufacturer(self, manufacturer_id, category, **kwargs):
        """
        Update a manufacturer
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.update_manufacturer(manufacturer_id, category, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int manufacturer_id: Manufacturer id (required)
        :param ManufacturerNew category: Manufacturer to update (required)
        :return: Manufacturer
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.update_manufacturer_with_http_info(manufacturer_id, category, **kwargs)
        else:
            (data) = self.update_manufacturer_with_http_info(manufacturer_id, category, **kwargs)
            return data

    def update_manufacturer_with_http_info(self, manufacturer_id, category, **kwargs):
        """
        Update a manufacturer
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.update_manufacturer_with_http_info(manufacturer_id, category, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int manufacturer_id: Manufacturer id (required)
        :param ManufacturerNew category: Manufacturer to update (required)
        :return: Manufacturer
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['manufacturer_id', 'category']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method update_manufacturer" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'manufacturer_id' is set
        if ('manufacturer_id' not in params) or (params['manufacturer_id'] is None):
            raise ValueError("Missing the required parameter `manufacturer_id` when calling `update_manufacturer`")
        # verify the required parameter 'category' is set
        if ('category' not in params) or (params['category'] is None):
            raise ValueError("Missing the required parameter `category` when calling `update_manufacturer`")


        collection_formats = {}

        path_params = {}
        if 'manufacturer_id' in params:
            path_params['manufacturer_id'] = params['manufacturer_id']

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'category' in params:
            body_params = params['category']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = []

        return self.api_client.call_api('/manufacturers/{manufacturer_id}', 'PUT',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type='Manufacturer',
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    def update_model(self, model_id, model, **kwargs):
        """
        Update model
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.update_model(model_id, model, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int model_id: Footprint id (required)
        :param ModelNew model: Model to update (required)
        :return: Model
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.update_model_with_http_info(model_id, model, **kwargs)
        else:
            (data) = self.update_model_with_http_info(model_id, model, **kwargs)
            return data

    def update_model_with_http_info(self, model_id, model, **kwargs):
        """
        Update model
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.update_model_with_http_info(model_id, model, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int model_id: Footprint id (required)
        :param ModelNew model: Model to update (required)
        :return: Model
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['model_id', 'model']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method update_model" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'model_id' is set
        if ('model_id' not in params) or (params['model_id'] is None):
            raise ValueError("Missing the required parameter `model_id` when calling `update_model`")
        # verify the required parameter 'model' is set
        if ('model' not in params) or (params['model'] is None):
            raise ValueError("Missing the required parameter `model` when calling `update_model`")


        collection_formats = {}

        path_params = {}
        if 'model_id' in params:
            path_params['model_id'] = params['model_id']

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'model' in params:
            body_params = params['model']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = []

        return self.api_client.call_api('/models/{model_id}', 'PUT',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type='Model',
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    def update_models_category(self, category_id, category, **kwargs):
        """
        Update model category
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.update_models_category(category_id, category, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int category_id: Category id (required)
        :param ModelCategoryNew category: Category to update (required)
        :return: ModelCategory
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.update_models_category_with_http_info(category_id, category, **kwargs)
        else:
            (data) = self.update_models_category_with_http_info(category_id, category, **kwargs)
            return data

    def update_models_category_with_http_info(self, category_id, category, **kwargs):
        """
        Update model category
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.update_models_category_with_http_info(category_id, category, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int category_id: Category id (required)
        :param ModelCategoryNew category: Category to update (required)
        :return: ModelCategory
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['category_id', 'category']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method update_models_category" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'category_id' is set
        if ('category_id' not in params) or (params['category_id'] is None):
            raise ValueError("Missing the required parameter `category_id` when calling `update_models_category`")
        # verify the required parameter 'category' is set
        if ('category' not in params) or (params['category'] is None):
            raise ValueError("Missing the required parameter `category` when calling `update_models_category`")


        collection_formats = {}

        path_params = {}
        if 'category_id' in params:
            path_params['category_id'] = params['category_id']

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'category' in params:
            body_params = params['category']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = []

        return self.api_client.call_api('/models/categories/{category_id}', 'PUT',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type='ModelCategory',
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    def update_part(self, part_id, part, **kwargs):
        """
        Update part
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.update_part(part_id, part, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int part_id: Part id (required)
        :param Part part: Part to update (required)
        :return: Part
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.update_part_with_http_info(part_id, part, **kwargs)
        else:
            (data) = self.update_part_with_http_info(part_id, part, **kwargs)
            return data

    def update_part_with_http_info(self, part_id, part, **kwargs):
        """
        Update part
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.update_part_with_http_info(part_id, part, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int part_id: Part id (required)
        :param Part part: Part to update (required)
        :return: Part
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['part_id', 'part']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method update_part" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'part_id' is set
        if ('part_id' not in params) or (params['part_id'] is None):
            raise ValueError("Missing the required parameter `part_id` when calling `update_part`")
        # verify the required parameter 'part' is set
        if ('part' not in params) or (params['part'] is None):
            raise ValueError("Missing the required parameter `part` when calling `update_part`")


        collection_formats = {}

        path_params = {}
        if 'part_id' in params:
            path_params['part_id'] = params['part_id']

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'part' in params:
            body_params = params['part']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = []

        return self.api_client.call_api('/parts/{part_id}', 'PUT',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type='Part',
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    def update_parts_category(self, category_id, category, **kwargs):
        """
        Update part category
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.update_parts_category(category_id, category, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int category_id: Category id (required)
        :param PartCategoryNew category: Category to update (required)
        :return: PartCategory
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.update_parts_category_with_http_info(category_id, category, **kwargs)
        else:
            (data) = self.update_parts_category_with_http_info(category_id, category, **kwargs)
            return data

    def update_parts_category_with_http_info(self, category_id, category, **kwargs):
        """
        Update part category
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.update_parts_category_with_http_info(category_id, category, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int category_id: Category id (required)
        :param PartCategoryNew category: Category to update (required)
        :return: PartCategory
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['category_id', 'category']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method update_parts_category" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'category_id' is set
        if ('category_id' not in params) or (params['category_id'] is None):
            raise ValueError("Missing the required parameter `category_id` when calling `update_parts_category`")
        # verify the required parameter 'category' is set
        if ('category' not in params) or (params['category'] is None):
            raise ValueError("Missing the required parameter `category` when calling `update_parts_category`")


        collection_formats = {}

        path_params = {}
        if 'category_id' in params:
            path_params['category_id'] = params['category_id']

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'category' in params:
            body_params = params['category']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = []

        return self.api_client.call_api('/parts/categories/{category_id}', 'PUT',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type='PartCategory',
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    def update_storage(self, storage_id, storage, **kwargs):
        """
        Update storage
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.update_storage(storage_id, storage, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int storage_id: Storage id (required)
        :param StorageNew storage: Storage to update (required)
        :return: Storage
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.update_storage_with_http_info(storage_id, storage, **kwargs)
        else:
            (data) = self.update_storage_with_http_info(storage_id, storage, **kwargs)
            return data

    def update_storage_with_http_info(self, storage_id, storage, **kwargs):
        """
        Update storage
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.update_storage_with_http_info(storage_id, storage, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int storage_id: Storage id (required)
        :param StorageNew storage: Storage to update (required)
        :return: Storage
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['storage_id', 'storage']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method update_storage" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'storage_id' is set
        if ('storage_id' not in params) or (params['storage_id'] is None):
            raise ValueError("Missing the required parameter `storage_id` when calling `update_storage`")
        # verify the required parameter 'storage' is set
        if ('storage' not in params) or (params['storage'] is None):
            raise ValueError("Missing the required parameter `storage` when calling `update_storage`")


        collection_formats = {}

        path_params = {}
        if 'storage_id' in params:
            path_params['storage_id'] = params['storage_id']

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'storage' in params:
            body_params = params['storage']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = []

        return self.api_client.call_api('/storages/{storage_id}', 'PUT',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type='Storage',
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    def update_storages_category(self, category_id, category, **kwargs):
        """
        Update storage category
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.update_storages_category(category_id, category, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int category_id: Category id (required)
        :param StorageCategoryNew category: Category to update (required)
        :return: StorageCategory
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.update_storages_category_with_http_info(category_id, category, **kwargs)
        else:
            (data) = self.update_storages_category_with_http_info(category_id, category, **kwargs)
            return data

    def update_storages_category_with_http_info(self, category_id, category, **kwargs):
        """
        Update storage category
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.update_storages_category_with_http_info(category_id, category, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int category_id: Category id (required)
        :param StorageCategoryNew category: Category to update (required)
        :return: StorageCategory
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['category_id', 'category']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method update_storages_category" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'category_id' is set
        if ('category_id' not in params) or (params['category_id'] is None):
            raise ValueError("Missing the required parameter `category_id` when calling `update_storages_category`")
        # verify the required parameter 'category' is set
        if ('category' not in params) or (params['category'] is None):
            raise ValueError("Missing the required parameter `category` when calling `update_storages_category`")


        collection_formats = {}

        path_params = {}
        if 'category_id' in params:
            path_params['category_id'] = params['category_id']

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'category' in params:
            body_params = params['category']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = []

        return self.api_client.call_api('/storages/categories/{category_id}', 'PUT',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type='StorageCategory',
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)
