# coding: utf-8

"""
    tosca-sure

    TOSCA Simple qUeRy sErvice (SURE).   # noqa: E501

    OpenAPI spec version: 1.0.0
    Contact: S.Koulouzis@uva.nl
    Generated by: https://github.com/swagger-api/swagger-codegen.git
"""


from __future__ import absolute_import

import re  # noqa: F401

# python 2 and python 3 compatibility library
import six

from sure_tosca_client.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):
        if api_client is None:
            api_client = ApiClient()
        self.api_client = api_client

    def get_all_ancestor_properties(self, id, node_name, **kwargs):  # noqa: E501
        """  # noqa: E501

        Recursively get all requirements all the way to the ROOT including the input node's  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_all_ancestor_properties(id, node_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: ID of topolog template uplodaed (required)
        :param str node_name: node_name (required)
        :return: list[dict(str, object)]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_all_ancestor_properties_with_http_info(id, node_name, **kwargs)  # noqa: E501
        else:
            (data) = self.get_all_ancestor_properties_with_http_info(id, node_name, **kwargs)  # noqa: E501
            return data

    def get_all_ancestor_properties_with_http_info(self, id, node_name, **kwargs):  # noqa: E501
        """  # noqa: E501

        Recursively get all requirements all the way to the ROOT including the input node's  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_all_ancestor_properties_with_http_info(id, node_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: ID of topolog template uplodaed (required)
        :param str node_name: node_name (required)
        :return: list[dict(str, object)]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['id', 'node_name']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

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

        collection_formats = {}

        path_params = {}
        if 'id' in params:
            path_params['id'] = params['id']  # noqa: E501
        if 'node_name' in params:
            path_params['node_name'] = params['node_name']  # noqa: E501

        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'])  # noqa: E501

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/tosca_template/{id}/topology_template/node_templates/{node_name}/ancestors_properties', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[dict(str, object)]',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _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 get_all_ancestor_types(self, id, node_name, **kwargs):  # noqa: E501
        """  # noqa: E501

        Recursively get all requirements all the way to the ROOT including the input node's  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_all_ancestor_types(id, node_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: ID of topolog template uplodaed (required)
        :param str node_name: node_name (required)
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_all_ancestor_types_with_http_info(id, node_name, **kwargs)  # noqa: E501
        else:
            (data) = self.get_all_ancestor_types_with_http_info(id, node_name, **kwargs)  # noqa: E501
            return data

    def get_all_ancestor_types_with_http_info(self, id, node_name, **kwargs):  # noqa: E501
        """  # noqa: E501

        Recursively get all requirements all the way to the ROOT including the input node's  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_all_ancestor_types_with_http_info(id, node_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: ID of topolog template uplodaed (required)
        :param str node_name: node_name (required)
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['id', 'node_name']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

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

        collection_formats = {}

        path_params = {}
        if 'id' in params:
            path_params['id'] = params['id']  # noqa: E501
        if 'node_name' in params:
            path_params['node_name'] = params['node_name']  # noqa: E501

        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'])  # noqa: E501

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/tosca_template/{id}/topology_template/node_templates/{node_name}/ancestors_types', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[str]',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _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 get_ancestors_requirements(self, id, node_name, **kwargs):  # noqa: E501
        """  # noqa: E501

        Recursively get all requirements all the way to the ROOT including the input node's  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_ancestors_requirements(id, node_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: ID of topolog template uplodaed (required)
        :param str node_name: node_name (required)
        :return: dict(str, object)
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_ancestors_requirements_with_http_info(id, node_name, **kwargs)  # noqa: E501
        else:
            (data) = self.get_ancestors_requirements_with_http_info(id, node_name, **kwargs)  # noqa: E501
            return data

    def get_ancestors_requirements_with_http_info(self, id, node_name, **kwargs):  # noqa: E501
        """  # noqa: E501

        Recursively get all requirements all the way to the ROOT including the input node's  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_ancestors_requirements_with_http_info(id, node_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: ID of topolog template uplodaed (required)
        :param str node_name: node_name (required)
        :return: dict(str, object)
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['id', 'node_name']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

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

        collection_formats = {}

        path_params = {}
        if 'id' in params:
            path_params['id'] = params['id']  # noqa: E501
        if 'node_name' in params:
            path_params['node_name'] = params['node_name']  # noqa: E501

        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'])  # noqa: E501

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/tosca_template/{id}/topology_template/node_templates/{node_name}/ancestors_requirements', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='dict(str, object)',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _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 get_dsl_definitions(self, id, **kwargs):  # noqa: E501
        """  # noqa: E501

        returns the interface types  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_dsl_definitions(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: ID of topolog template uplodaed (required)
        :param list[str] anchors: the anchors the definition is for
        :param str derived_from: derived from
        :return: list[dict(str, object)]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_dsl_definitions_with_http_info(id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_dsl_definitions_with_http_info(id, **kwargs)  # noqa: E501
            return data

    def get_dsl_definitions_with_http_info(self, id, **kwargs):  # noqa: E501
        """  # noqa: E501

        returns the interface types  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_dsl_definitions_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: ID of topolog template uplodaed (required)
        :param list[str] anchors: the anchors the definition is for
        :param str derived_from: derived from
        :return: list[dict(str, object)]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['id', 'anchors', 'derived_from']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

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

        collection_formats = {}

        path_params = {}
        if 'id' in params:
            path_params['id'] = params['id']  # noqa: E501

        query_params = []
        if 'anchors' in params:
            query_params.append(('anchors', params['anchors']))  # noqa: E501
            collection_formats['anchors'] = 'multi'  # noqa: E501
        if 'derived_from' in params:
            query_params.append(('derived_from', params['derived_from']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

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

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/tosca_template/{id}/dsl_definitions', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[dict(str, object)]',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _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 get_imports(self, id, **kwargs):  # noqa: E501
        """  # noqa: E501

        returns the interface types  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_imports(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: ID of topolog template uplodaed (required)
        :return: list[dict(str, object)]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_imports_with_http_info(id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_imports_with_http_info(id, **kwargs)  # noqa: E501
            return data

    def get_imports_with_http_info(self, id, **kwargs):  # noqa: E501
        """  # noqa: E501

        returns the interface types  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_imports_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: ID of topolog template uplodaed (required)
        :return: list[dict(str, object)]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

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

        collection_formats = {}

        path_params = {}
        if 'id' in params:
            path_params['id'] = params['id']  # noqa: E501

        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'])  # noqa: E501

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/tosca_template/{id}/imports', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[dict(str, object)]',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _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 get_node_outputs(self, id, node_name, **kwargs):  # noqa: E501
        """  # noqa: E501

        s  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_node_outputs(id, node_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: ID of topolog template uplodaed (required)
        :param str node_name: node_name (required)
        :return: list[dict(str, object)]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_node_outputs_with_http_info(id, node_name, **kwargs)  # noqa: E501
        else:
            (data) = self.get_node_outputs_with_http_info(id, node_name, **kwargs)  # noqa: E501
            return data

    def get_node_outputs_with_http_info(self, id, node_name, **kwargs):  # noqa: E501
        """  # noqa: E501

        s  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_node_outputs_with_http_info(id, node_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: ID of topolog template uplodaed (required)
        :param str node_name: node_name (required)
        :return: list[dict(str, object)]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['id', 'node_name']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

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

        collection_formats = {}

        path_params = {}
        if 'id' in params:
            path_params['id'] = params['id']  # noqa: E501
        if 'node_name' in params:
            path_params['node_name'] = params['node_name']  # noqa: E501

        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'])  # noqa: E501

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/tosca_template/{id}/topology_template/node_templates/{node_name}/outputs', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[dict(str, object)]',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _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 get_node_properties(self, id, node_name, **kwargs):  # noqa: E501
        """  # noqa: E501

        s  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_node_properties(id, node_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: ID of topolog template uplodaed (required)
        :param str node_name: node_name (required)
        :return: dict(str, object)
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_node_properties_with_http_info(id, node_name, **kwargs)  # noqa: E501
        else:
            (data) = self.get_node_properties_with_http_info(id, node_name, **kwargs)  # noqa: E501
            return data

    def get_node_properties_with_http_info(self, id, node_name, **kwargs):  # noqa: E501
        """  # noqa: E501

        s  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_node_properties_with_http_info(id, node_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: ID of topolog template uplodaed (required)
        :param str node_name: node_name (required)
        :return: dict(str, object)
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['id', 'node_name']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

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

        collection_formats = {}

        path_params = {}
        if 'id' in params:
            path_params['id'] = params['id']  # noqa: E501
        if 'node_name' in params:
            path_params['node_name'] = params['node_name']  # noqa: E501

        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'])  # noqa: E501

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/tosca_template/{id}/topology_template/node_templates/{node_name}/properties', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='dict(str, object)',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _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 get_node_requirements(self, id, node_name, **kwargs):  # noqa: E501
        """get_node_requirements  # noqa: E501

        Returns  the requirements for an input node as described in the template not in the node's definition   # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_node_requirements(id, node_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: ID of topolog template uplodaed (required)
        :param str node_name: node_name (required)
        :return: dict(str, object)
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_node_requirements_with_http_info(id, node_name, **kwargs)  # noqa: E501
        else:
            (data) = self.get_node_requirements_with_http_info(id, node_name, **kwargs)  # noqa: E501
            return data

    def get_node_requirements_with_http_info(self, id, node_name, **kwargs):  # noqa: E501
        """get_node_requirements  # noqa: E501

        Returns  the requirements for an input node as described in the template not in the node's definition   # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_node_requirements_with_http_info(id, node_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: ID of topolog template uplodaed (required)
        :param str node_name: node_name (required)
        :return: dict(str, object)
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['id', 'node_name']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

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

        collection_formats = {}

        path_params = {}
        if 'id' in params:
            path_params['id'] = params['id']  # noqa: E501
        if 'node_name' in params:
            path_params['node_name'] = params['node_name']  # noqa: E501

        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'])  # noqa: E501

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/tosca_template/{id}/topology_template/node_templates/{node_name}/requirements', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='dict(str, object)',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _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 get_node_templates(self, id, **kwargs):  # noqa: E501
        """get_node_templates  # noqa: E501

        returns nodes templates in topology  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_node_templates(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: ID of topolog template uplodaed (required)
        :param str type_name: The type
        :param str node_name: the name
        :param bool has_interfaces: filter if has interfaces
        :param bool has_properties: filter if has properties
        :param bool has_attributes: filter if has attributes
        :param bool has_requirements: filter if has requirements
        :param bool has_capabilities: filter if has capabilities
        :param bool has_artifacts: filter if has artifacts
        :return: list[NodeTemplateMap]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_node_templates_with_http_info(id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_node_templates_with_http_info(id, **kwargs)  # noqa: E501
            return data

    def get_node_templates_with_http_info(self, id, **kwargs):  # noqa: E501
        """get_node_templates  # noqa: E501

        returns nodes templates in topology  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_node_templates_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: ID of topolog template uplodaed (required)
        :param str type_name: The type
        :param str node_name: the name
        :param bool has_interfaces: filter if has interfaces
        :param bool has_properties: filter if has properties
        :param bool has_attributes: filter if has attributes
        :param bool has_requirements: filter if has requirements
        :param bool has_capabilities: filter if has capabilities
        :param bool has_artifacts: filter if has artifacts
        :return: list[NodeTemplateMap]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['id', 'type_name', 'node_name', 'has_interfaces', 'has_properties', 'has_attributes', 'has_requirements', 'has_capabilities', 'has_artifacts']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

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

        collection_formats = {}

        path_params = {}
        if 'id' in params:
            path_params['id'] = params['id']  # noqa: E501

        query_params = []
        if 'type_name' in params:
            query_params.append(('type_name', params['type_name']))  # noqa: E501
        if 'node_name' in params:
            query_params.append(('node_name', params['node_name']))  # noqa: E501
        if 'has_interfaces' in params:
            query_params.append(('has_interfaces', params['has_interfaces']))  # noqa: E501
        if 'has_properties' in params:
            query_params.append(('has_properties', params['has_properties']))  # noqa: E501
        if 'has_attributes' in params:
            query_params.append(('has_attributes', params['has_attributes']))  # noqa: E501
        if 'has_requirements' in params:
            query_params.append(('has_requirements', params['has_requirements']))  # noqa: E501
        if 'has_capabilities' in params:
            query_params.append(('has_capabilities', params['has_capabilities']))  # noqa: E501
        if 'has_artifacts' in params:
            query_params.append(('has_artifacts', params['has_artifacts']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

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

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/tosca_template/{id}/topology_template/node_templates', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NodeTemplateMap]',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _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 get_node_type_name(self, id, node_name, **kwargs):  # noqa: E501
        """  # noqa: E501

          # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_node_type_name(id, node_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: ID of topolog template uplodaed (required)
        :param str node_name: node_name (required)
        :return: str
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_node_type_name_with_http_info(id, node_name, **kwargs)  # noqa: E501
        else:
            (data) = self.get_node_type_name_with_http_info(id, node_name, **kwargs)  # noqa: E501
            return data

    def get_node_type_name_with_http_info(self, id, node_name, **kwargs):  # noqa: E501
        """  # noqa: E501

          # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_node_type_name_with_http_info(id, node_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: ID of topolog template uplodaed (required)
        :param str node_name: node_name (required)
        :return: str
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['id', 'node_name']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

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

        collection_formats = {}

        path_params = {}
        if 'id' in params:
            path_params['id'] = params['id']  # noqa: E501
        if 'node_name' in params:
            path_params['node_name'] = params['node_name']  # noqa: E501

        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'])  # noqa: E501

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/tosca_template/{id}/topology_template/node_templates/{node_name}/type_name', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='str',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _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 get_parent_type_name(self, id, node_name, **kwargs):  # noqa: E501
        """  # noqa: E501

          # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_parent_type_name(id, node_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: ID of topolog template uplodaed (required)
        :param str node_name: node_name (required)
        :return: str
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_parent_type_name_with_http_info(id, node_name, **kwargs)  # noqa: E501
        else:
            (data) = self.get_parent_type_name_with_http_info(id, node_name, **kwargs)  # noqa: E501
            return data

    def get_parent_type_name_with_http_info(self, id, node_name, **kwargs):  # noqa: E501
        """  # noqa: E501

          # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_parent_type_name_with_http_info(id, node_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: ID of topolog template uplodaed (required)
        :param str node_name: node_name (required)
        :return: str
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['id', 'node_name']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

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

        collection_formats = {}

        path_params = {}
        if 'id' in params:
            path_params['id'] = params['id']  # noqa: E501
        if 'node_name' in params:
            path_params['node_name'] = params['node_name']  # noqa: E501

        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'])  # noqa: E501

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/tosca_template/{id}/topology_template/node_templates/{node_name}/derived_from', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='str',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _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 get_related_nodes(self, id, node_name, **kwargs):  # noqa: E501
        """  # noqa: E501

        s  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_related_nodes(id, node_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: ID of topolog template uplodaed (required)
        :param str node_name: node_name (required)
        :return: list[NodeTemplateMap]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_related_nodes_with_http_info(id, node_name, **kwargs)  # noqa: E501
        else:
            (data) = self.get_related_nodes_with_http_info(id, node_name, **kwargs)  # noqa: E501
            return data

    def get_related_nodes_with_http_info(self, id, node_name, **kwargs):  # noqa: E501
        """  # noqa: E501

        s  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_related_nodes_with_http_info(id, node_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: ID of topolog template uplodaed (required)
        :param str node_name: node_name (required)
        :return: list[NodeTemplateMap]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['id', 'node_name']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

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

        collection_formats = {}

        path_params = {}
        if 'id' in params:
            path_params['id'] = params['id']  # noqa: E501
        if 'node_name' in params:
            path_params['node_name'] = params['node_name']  # noqa: E501

        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'])  # noqa: E501

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/tosca_template/{id}/topology_template/node_templates/{node_name}/related', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NodeTemplateMap]',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _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 get_relationship_templates(self, id, **kwargs):  # noqa: E501
        """  # noqa: E501

        returns the interface types  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_relationship_templates(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: ID of topolog template uplodaed (required)
        :param str type_name: The relationship type
        :param str derived_from: derived from
        :return: list[dict(str, object)]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_relationship_templates_with_http_info(id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_relationship_templates_with_http_info(id, **kwargs)  # noqa: E501
            return data

    def get_relationship_templates_with_http_info(self, id, **kwargs):  # noqa: E501
        """  # noqa: E501

        returns the interface types  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_relationship_templates_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: ID of topolog template uplodaed (required)
        :param str type_name: The relationship type
        :param str derived_from: derived from
        :return: list[dict(str, object)]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['id', 'type_name', 'derived_from']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

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

        collection_formats = {}

        path_params = {}
        if 'id' in params:
            path_params['id'] = params['id']  # noqa: E501

        query_params = []
        if 'type_name' in params:
            query_params.append(('type_name', params['type_name']))  # noqa: E501
        if 'derived_from' in params:
            query_params.append(('derived_from', params['derived_from']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

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

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/tosca_template/{id}/relationship_templates', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[dict(str, object)]',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _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 get_topology_template(self, id, **kwargs):  # noqa: E501
        """get_topology_template  # noqa: E501

        r  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_topology_template(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: ID of topolog template uplodaed (required)
        :return: TopologyTemplate
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_topology_template_with_http_info(id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_topology_template_with_http_info(id, **kwargs)  # noqa: E501
            return data

    def get_topology_template_with_http_info(self, id, **kwargs):  # noqa: E501
        """get_topology_template  # noqa: E501

        r  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_topology_template_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: ID of topolog template uplodaed (required)
        :return: TopologyTemplate
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

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

        collection_formats = {}

        path_params = {}
        if 'id' in params:
            path_params['id'] = params['id']  # noqa: E501

        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'])  # noqa: E501

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/tosca_template/{id}/topology_template', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='TopologyTemplate',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _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 get_tosca_template(self, id, **kwargs):  # noqa: E501
        """get_tosca_template  # noqa: E501

          # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_tosca_template(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: ID of topolog template uplodaed (required)
        :return: ToscaTemplate
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_tosca_template_with_http_info(id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_tosca_template_with_http_info(id, **kwargs)  # noqa: E501
            return data

    def get_tosca_template_with_http_info(self, id, **kwargs):  # noqa: E501
        """get_tosca_template  # noqa: E501

          # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_tosca_template_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: ID of topolog template uplodaed (required)
        :return: ToscaTemplate
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

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

        collection_formats = {}

        path_params = {}
        if 'id' in params:
            path_params['id'] = params['id']  # noqa: E501

        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'])  # noqa: E501

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/tosca_template/{id}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ToscaTemplate',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _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 get_types(self, id, **kwargs):  # noqa: E501
        """  # noqa: E501

        returns the interface types  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_types(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: ID of topolog template uplodaed (required)
        :param str kind_of_type: the type we are looking for e.g. capability_types, artifact_types. etc.
        :param bool has_interfaces: filter if has interfaces
        :param str type_name: The type_name
        :param bool has_properties: filter if has properties
        :param bool has_attributes: filter if has attributes
        :param bool has_requirements: filter if has requirements
        :param bool has_capabilities: filter if has capabilities
        :param bool has_artifacts: filter if has artifacts
        :param str derived_from: derived from
        :return: list[dict(str, object)]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_types_with_http_info(id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_types_with_http_info(id, **kwargs)  # noqa: E501
            return data

    def get_types_with_http_info(self, id, **kwargs):  # noqa: E501
        """  # noqa: E501

        returns the interface types  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_types_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: ID of topolog template uplodaed (required)
        :param str kind_of_type: the type we are looking for e.g. capability_types, artifact_types. etc.
        :param bool has_interfaces: filter if has interfaces
        :param str type_name: The type_name
        :param bool has_properties: filter if has properties
        :param bool has_attributes: filter if has attributes
        :param bool has_requirements: filter if has requirements
        :param bool has_capabilities: filter if has capabilities
        :param bool has_artifacts: filter if has artifacts
        :param str derived_from: derived from
        :return: list[dict(str, object)]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['id', 'kind_of_type', 'has_interfaces', 'type_name', 'has_properties', 'has_attributes', 'has_requirements', 'has_capabilities', 'has_artifacts', 'derived_from']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

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

        collection_formats = {}

        path_params = {}
        if 'id' in params:
            path_params['id'] = params['id']  # noqa: E501

        query_params = []
        if 'kind_of_type' in params:
            query_params.append(('kind_of_type', params['kind_of_type']))  # noqa: E501
        if 'has_interfaces' in params:
            query_params.append(('has_interfaces', params['has_interfaces']))  # noqa: E501
        if 'type_name' in params:
            query_params.append(('type_name', params['type_name']))  # noqa: E501
        if 'has_properties' in params:
            query_params.append(('has_properties', params['has_properties']))  # noqa: E501
        if 'has_attributes' in params:
            query_params.append(('has_attributes', params['has_attributes']))  # noqa: E501
        if 'has_requirements' in params:
            query_params.append(('has_requirements', params['has_requirements']))  # noqa: E501
        if 'has_capabilities' in params:
            query_params.append(('has_capabilities', params['has_capabilities']))  # noqa: E501
        if 'has_artifacts' in params:
            query_params.append(('has_artifacts', params['has_artifacts']))  # noqa: E501
        if 'derived_from' in params:
            query_params.append(('derived_from', params['derived_from']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

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

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/tosca_template/{id}/types', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[dict(str, object)]',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _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 set_node_properties(self, id, properties, node_name, **kwargs):  # noqa: E501
        """  # noqa: E501

        s  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.set_node_properties(id, properties, node_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: ID of topolog template uplodaed (required)
        :param object properties: (required)
        :param str node_name: node_name (required)
        :return: str
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.set_node_properties_with_http_info(id, properties, node_name, **kwargs)  # noqa: E501
        else:
            (data) = self.set_node_properties_with_http_info(id, properties, node_name, **kwargs)  # noqa: E501
            return data

    def set_node_properties_with_http_info(self, id, properties, node_name, **kwargs):  # noqa: E501
        """  # noqa: E501

        s  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.set_node_properties_with_http_info(id, properties, node_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: ID of topolog template uplodaed (required)
        :param object properties: (required)
        :param str node_name: node_name (required)
        :return: str
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['id', 'properties', 'node_name']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

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

        collection_formats = {}

        path_params = {}
        if 'id' in params:
            path_params['id'] = params['id']  # noqa: E501
        if 'node_name' in params:
            path_params['node_name'] = params['node_name']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/tosca_template/{id}/topology_template/node_templates/{node_name}/properties', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='str',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _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 upload_tosca_template(self, file, **kwargs):  # noqa: E501
        """upload a tosca template description file  # noqa: E501

        upload and validate a tosca template description file  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.upload_tosca_template(file, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param file file: tosca Template description (required)
        :return: str
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.upload_tosca_template_with_http_info(file, **kwargs)  # noqa: E501
        else:
            (data) = self.upload_tosca_template_with_http_info(file, **kwargs)  # noqa: E501
            return data

    def upload_tosca_template_with_http_info(self, file, **kwargs):  # noqa: E501
        """upload a tosca template description file  # noqa: E501

        upload and validate a tosca template description file  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.upload_tosca_template_with_http_info(file, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param file file: tosca Template description (required)
        :return: str
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['file']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

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

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}
        if 'file' in params:
            local_var_files['file'] = params['file']  # noqa: E501

        body_params = None
        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['multipart/form-data'])  # noqa: E501

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/tosca_template', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='str',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _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)
