# coding: utf-8

"""
    QEDIT - Asset Transfers

    This SDK provides a programmatic way for interacting with QEDIT's _Asset Transfer_ API. The specification definition file is publicly available [in this repository](https://github.com/QED-it/asset_transfers_dev_guide/).   # noqa: E501

    OpenAPI spec version: 1.7.2
    Contact: dev@qed-it.com
    Generated by: https://openapi-generator.tech
"""


from __future__ import absolute_import

import re  # noqa: F401

# python 2 and python 3 compatibility library
import six

from pyqedit.api_client import ApiClient


class NodeApi(object):
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None):
        if api_client is None:
            api_client = ApiClient()
        self.api_client = api_client

    def node_approve_task_post(self, task_action_request, **kwargs):  # noqa: E501
        """Approve task with pending incoming transaction [async call]  # noqa: E501

        Confirmation request tasks are confirmed using this point. After the user confirms the incoming transaction, it is asynchronously sent to the blockchain and its status can be queried like any other async task.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_approve_task_post(task_action_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param TaskActionRequest task_action_request: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_approve_task_post_with_http_info(task_action_request, **kwargs)  # noqa: E501
        else:
            (data) = self.node_approve_task_post_with_http_info(task_action_request, **kwargs)  # noqa: E501
            return data

    def node_approve_task_post_with_http_info(self, task_action_request, **kwargs):  # noqa: E501
        """Approve task with pending incoming transaction [async call]  # noqa: E501

        Confirmation request tasks are confirmed using this point. After the user confirms the incoming transaction, it is asynchronously sent to the blockchain and its status can be queried like any other async task.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_approve_task_post_with_http_info(task_action_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param TaskActionRequest task_action_request: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

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

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

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        # Authentication setting
        auth_settings = ['ApiKeyAuth']  # noqa: E501

        return self.api_client.call_api(
            '/node/approve_task', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def node_cancel_task_post(self, task_action_request, **kwargs):  # noqa: E501
        """Cancel task with pending incoming transaction both incoming and outgoing [async call]  # noqa: E501

        A user may select to decline an incoming transaction. The related task will change its result to failure both on senders and the receivers side. This endpoint can also be used to cancel an outgoing pending transaction that is awaiting user interaction from the receiver  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_cancel_task_post(task_action_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param TaskActionRequest task_action_request: (required)
        :return: AsyncTaskCreatedResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_cancel_task_post_with_http_info(task_action_request, **kwargs)  # noqa: E501
        else:
            (data) = self.node_cancel_task_post_with_http_info(task_action_request, **kwargs)  # noqa: E501
            return data

    def node_cancel_task_post_with_http_info(self, task_action_request, **kwargs):  # noqa: E501
        """Cancel task with pending incoming transaction both incoming and outgoing [async call]  # noqa: E501

        A user may select to decline an incoming transaction. The related task will change its result to failure both on senders and the receivers side. This endpoint can also be used to cancel an outgoing pending transaction that is awaiting user interaction from the receiver  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_cancel_task_post_with_http_info(task_action_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param TaskActionRequest task_action_request: (required)
        :return: AsyncTaskCreatedResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

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

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

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        # Authentication setting
        auth_settings = ['ApiKeyAuth']  # noqa: E501

        return self.api_client.call_api(
            '/node/cancel_task', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='AsyncTaskCreatedResponse',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def node_delete_wallet_post(self, delete_wallet_request, **kwargs):  # noqa: E501
        """Delete a Wallet [async call]  # noqa: E501

        Deletes a Wallet from the Node; All private information about the Wallet will be deleted including transactional history, balances, and keys; If the secret key of the Wallet are not stored elsewhere then all Assets held in the Wallet will be forever lost! If the secret key of the Wallet is stored elsewhere, then all held Assets and the entire transactional history of the Wallet can be restored from the Blockchain at any time by importing the Wallet into a Node.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_delete_wallet_post(delete_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteWalletRequest delete_wallet_request: (required)
        :return: AsyncTaskCreatedResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_delete_wallet_post_with_http_info(delete_wallet_request, **kwargs)  # noqa: E501
        else:
            (data) = self.node_delete_wallet_post_with_http_info(delete_wallet_request, **kwargs)  # noqa: E501
            return data

    def node_delete_wallet_post_with_http_info(self, delete_wallet_request, **kwargs):  # noqa: E501
        """Delete a Wallet [async call]  # noqa: E501

        Deletes a Wallet from the Node; All private information about the Wallet will be deleted including transactional history, balances, and keys; If the secret key of the Wallet are not stored elsewhere then all Assets held in the Wallet will be forever lost! If the secret key of the Wallet is stored elsewhere, then all held Assets and the entire transactional history of the Wallet can be restored from the Blockchain at any time by importing the Wallet into a Node.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_delete_wallet_post_with_http_info(delete_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteWalletRequest delete_wallet_request: (required)
        :return: AsyncTaskCreatedResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

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

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

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        # Authentication setting
        auth_settings = ['ApiKeyAuth']  # noqa: E501

        return self.api_client.call_api(
            '/node/delete_wallet', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='AsyncTaskCreatedResponse',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def node_export_auditor_access_wallet_post(self, export_auditor_access_wallet_request, **kwargs):  # noqa: E501
        """Export viewing credentials for a Wallet  # noqa: E501

        Export a viewing key that allows viewing all transactions to and from a wallet, including past transactions. The viewing key is encrypted for a specific Address, and can only be recovered by someone in possession of either a secret key or a viewing key for the Wallet that Address belongs to. The viewing key does enable making any transactions (including rule changes, issuance, and transfers) on behalf of the exported Wallet.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_export_auditor_access_wallet_post(export_auditor_access_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ExportAuditorAccessWalletRequest export_auditor_access_wallet_request: (required)
        :return: ExportAuditorAccessWalletResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_export_auditor_access_wallet_post_with_http_info(export_auditor_access_wallet_request, **kwargs)  # noqa: E501
        else:
            (data) = self.node_export_auditor_access_wallet_post_with_http_info(export_auditor_access_wallet_request, **kwargs)  # noqa: E501
            return data

    def node_export_auditor_access_wallet_post_with_http_info(self, export_auditor_access_wallet_request, **kwargs):  # noqa: E501
        """Export viewing credentials for a Wallet  # noqa: E501

        Export a viewing key that allows viewing all transactions to and from a wallet, including past transactions. The viewing key is encrypted for a specific Address, and can only be recovered by someone in possession of either a secret key or a viewing key for the Wallet that Address belongs to. The viewing key does enable making any transactions (including rule changes, issuance, and transfers) on behalf of the exported Wallet.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_export_auditor_access_wallet_post_with_http_info(export_auditor_access_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ExportAuditorAccessWalletRequest export_auditor_access_wallet_request: (required)
        :return: ExportAuditorAccessWalletResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

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

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

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        # Authentication setting
        auth_settings = ['ApiKeyAuth']  # noqa: E501

        return self.api_client.call_api(
            '/node/export_auditor_access_wallet', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ExportAuditorAccessWalletResponse',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def node_export_wallet_post(self, export_wallet_request, **kwargs):  # noqa: E501
        """Export wallet secret key  # noqa: E501

        Export an encrypted form of the Wallet's secret key; The authorization password under which the secret key is encrypted is the same one under which it was originally created or imported; Knowledge of the secret key and the authorization password is required to import the Wallet into a Node in the future.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_export_wallet_post(export_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ExportWalletRequest export_wallet_request: (required)
        :return: ExportWalletResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_export_wallet_post_with_http_info(export_wallet_request, **kwargs)  # noqa: E501
        else:
            (data) = self.node_export_wallet_post_with_http_info(export_wallet_request, **kwargs)  # noqa: E501
            return data

    def node_export_wallet_post_with_http_info(self, export_wallet_request, **kwargs):  # noqa: E501
        """Export wallet secret key  # noqa: E501

        Export an encrypted form of the Wallet's secret key; The authorization password under which the secret key is encrypted is the same one under which it was originally created or imported; Knowledge of the secret key and the authorization password is required to import the Wallet into a Node in the future.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_export_wallet_post_with_http_info(export_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ExportWalletRequest export_wallet_request: (required)
        :return: ExportWalletResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

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

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

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        # Authentication setting
        auth_settings = ['ApiKeyAuth']  # noqa: E501

        return self.api_client.call_api(
            '/node/export_wallet', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ExportWalletResponse',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def node_generate_wallet_post(self, generate_wallet_request, **kwargs):  # noqa: E501
        """Generate a new Wallet  # noqa: E501

        Randomly generate a new Wallet under a specified ID; This only affects the Node and in particular nothing about this action is broadcast to the Blockchain; The Wallet ID is required to be unique within the Node, but can otherwise be user-defined.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_generate_wallet_post(generate_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GenerateWalletRequest generate_wallet_request: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_generate_wallet_post_with_http_info(generate_wallet_request, **kwargs)  # noqa: E501
        else:
            (data) = self.node_generate_wallet_post_with_http_info(generate_wallet_request, **kwargs)  # noqa: E501
            return data

    def node_generate_wallet_post_with_http_info(self, generate_wallet_request, **kwargs):  # noqa: E501
        """Generate a new Wallet  # noqa: E501

        Randomly generate a new Wallet under a specified ID; This only affects the Node and in particular nothing about this action is broadcast to the Blockchain; The Wallet ID is required to be unique within the Node, but can otherwise be user-defined.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_generate_wallet_post_with_http_info(generate_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GenerateWalletRequest generate_wallet_request: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

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

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

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        # Authentication setting
        auth_settings = ['ApiKeyAuth']  # noqa: E501

        return self.api_client.call_api(
            '/node/generate_wallet', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def node_get_all_wallets_post(self, **kwargs):  # noqa: E501
        """Get all wallet IDs  # noqa: E501

        Returns a list of the IDs of all Wallets currently stored on the Node. Both full-access and view-only Wallets are listed.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_get_all_wallets_post(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :return: GetAllWalletsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_get_all_wallets_post_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.node_get_all_wallets_post_with_http_info(**kwargs)  # noqa: E501
            return data

    def node_get_all_wallets_post_with_http_info(self, **kwargs):  # noqa: E501
        """Get all wallet IDs  # noqa: E501

        Returns a list of the IDs of all Wallets currently stored on the Node. Both full-access and view-only Wallets are listed.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_get_all_wallets_post_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :return: GetAllWalletsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

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

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method node_get_all_wallets_post" % key
                )
            local_var_params[key] = val
        del local_var_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'])  # noqa: E501

        # Authentication setting
        auth_settings = ['ApiKeyAuth']  # noqa: E501

        return self.api_client.call_api(
            '/node/get_all_wallets', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='GetAllWalletsResponse',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def node_get_notifications_post(self, get_notifications_request, **kwargs):  # noqa: E501
        """Get notifications  # noqa: E501

        Notifications are the Node's way to report about recent activity and status changes. This endpoint allows polling for these changes and fetching the updates. The notifications can be filtered in multiple ways.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_get_notifications_post(get_notifications_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GetNotificationsRequest get_notifications_request: (required)
        :return: GetNotificationsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_get_notifications_post_with_http_info(get_notifications_request, **kwargs)  # noqa: E501
        else:
            (data) = self.node_get_notifications_post_with_http_info(get_notifications_request, **kwargs)  # noqa: E501
            return data

    def node_get_notifications_post_with_http_info(self, get_notifications_request, **kwargs):  # noqa: E501
        """Get notifications  # noqa: E501

        Notifications are the Node's way to report about recent activity and status changes. This endpoint allows polling for these changes and fetching the updates. The notifications can be filtered in multiple ways.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_get_notifications_post_with_http_info(get_notifications_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GetNotificationsRequest get_notifications_request: (required)
        :return: GetNotificationsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

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

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

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        # Authentication setting
        auth_settings = ['ApiKeyAuth']  # noqa: E501

        return self.api_client.call_api(
            '/node/get_notifications', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='GetNotificationsResponse',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def node_get_rules_post(self, **kwargs):  # noqa: E501
        """Get network governance Rules  # noqa: E501

        Returns a full list of all the Rules that govern admin and issuance rights within the network.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_get_rules_post(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :return: GetRulesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_get_rules_post_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.node_get_rules_post_with_http_info(**kwargs)  # noqa: E501
            return data

    def node_get_rules_post_with_http_info(self, **kwargs):  # noqa: E501
        """Get network governance Rules  # noqa: E501

        Returns a full list of all the Rules that govern admin and issuance rights within the network.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_get_rules_post_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :return: GetRulesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

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

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method node_get_rules_post" % key
                )
            local_var_params[key] = val
        del local_var_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'])  # noqa: E501

        # Authentication setting
        auth_settings = ['ApiKeyAuth']  # noqa: E501

        return self.api_client.call_api(
            '/node/get_rules', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='GetRulesResponse',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def node_get_task_status_post(self, get_task_status_request, **kwargs):  # noqa: E501
        """Get a specific task (by ID)  # noqa: E501

        Returns the meta-data of a given Task and its current status. The particular, private details of the Task such as an Asset ID or amount in a Transfer are not returned.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_get_task_status_post(get_task_status_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GetTaskStatusRequest get_task_status_request: (required)
        :return: GetTaskStatusResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_get_task_status_post_with_http_info(get_task_status_request, **kwargs)  # noqa: E501
        else:
            (data) = self.node_get_task_status_post_with_http_info(get_task_status_request, **kwargs)  # noqa: E501
            return data

    def node_get_task_status_post_with_http_info(self, get_task_status_request, **kwargs):  # noqa: E501
        """Get a specific task (by ID)  # noqa: E501

        Returns the meta-data of a given Task and its current status. The particular, private details of the Task such as an Asset ID or amount in a Transfer are not returned.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_get_task_status_post_with_http_info(get_task_status_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GetTaskStatusRequest get_task_status_request: (required)
        :return: GetTaskStatusResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

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

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

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        # Authentication setting
        auth_settings = ['ApiKeyAuth']  # noqa: E501

        return self.api_client.call_api(
            '/node/get_task_status', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='GetTaskStatusResponse',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def node_get_tasks_post(self, get_tasks_request, **kwargs):  # noqa: E501
        """Get a (potentially) filtered list of all Tasks  # noqa: E501

        Returns a list of all Tasks along with their meta-data and statuses. The particular, private details of the Task such as an Asset ID or amount in a Transfer are not returned. Tasks can be filtered using various parameters as specified in the request body.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_get_tasks_post(get_tasks_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GetTasksRequest get_tasks_request: (required)
        :return: GetTasksResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_get_tasks_post_with_http_info(get_tasks_request, **kwargs)  # noqa: E501
        else:
            (data) = self.node_get_tasks_post_with_http_info(get_tasks_request, **kwargs)  # noqa: E501
            return data

    def node_get_tasks_post_with_http_info(self, get_tasks_request, **kwargs):  # noqa: E501
        """Get a (potentially) filtered list of all Tasks  # noqa: E501

        Returns a list of all Tasks along with their meta-data and statuses. The particular, private details of the Task such as an Asset ID or amount in a Transfer are not returned. Tasks can be filtered using various parameters as specified in the request body.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_get_tasks_post_with_http_info(get_tasks_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GetTasksRequest get_tasks_request: (required)
        :return: GetTasksResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

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

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

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        # Authentication setting
        auth_settings = ['ApiKeyAuth']  # noqa: E501

        return self.api_client.call_api(
            '/node/get_tasks', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='GetTasksResponse',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def node_import_auditor_access_wallet_post(self, import_auditor_access_wallet_request, **kwargs):  # noqa: E501
        """Import viewing credentials for a Wallet [async call]  # noqa: E501

        Import a viewing key generated by the export_auditor_access_wallet endpoint. This will create a read-only wallet which can be queried with endpoints such as get_activity and get_balances, but cannot be used to perform transactions. The Wallet whose Address was used as the recipient for the exported viewing key must already be imported within the Node in order for this process to succeed.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_import_auditor_access_wallet_post(import_auditor_access_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ImportAuditorAccessWalletRequest import_auditor_access_wallet_request: (required)
        :return: AsyncTaskCreatedResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_import_auditor_access_wallet_post_with_http_info(import_auditor_access_wallet_request, **kwargs)  # noqa: E501
        else:
            (data) = self.node_import_auditor_access_wallet_post_with_http_info(import_auditor_access_wallet_request, **kwargs)  # noqa: E501
            return data

    def node_import_auditor_access_wallet_post_with_http_info(self, import_auditor_access_wallet_request, **kwargs):  # noqa: E501
        """Import viewing credentials for a Wallet [async call]  # noqa: E501

        Import a viewing key generated by the export_auditor_access_wallet endpoint. This will create a read-only wallet which can be queried with endpoints such as get_activity and get_balances, but cannot be used to perform transactions. The Wallet whose Address was used as the recipient for the exported viewing key must already be imported within the Node in order for this process to succeed.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_import_auditor_access_wallet_post_with_http_info(import_auditor_access_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ImportAuditorAccessWalletRequest import_auditor_access_wallet_request: (required)
        :return: AsyncTaskCreatedResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

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

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

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        # Authentication setting
        auth_settings = ['ApiKeyAuth']  # noqa: E501

        return self.api_client.call_api(
            '/node/import_auditor_access_wallet', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='AsyncTaskCreatedResponse',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def node_import_wallet_post(self, import_wallet_request, **kwargs):  # noqa: E501
        """Import Wallet from a known secret key and authorization [async call]  # noqa: E501

        Import a Wallet into the Node under a specified ID; All the transactional history and outstanding balanced of the Wallet will be extracted from the Blockchain; The Wallet ID is required to be unique within the Node, but can otherwise be user-defined.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_import_wallet_post(import_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ImportWalletRequest import_wallet_request: (required)
        :return: AsyncTaskCreatedResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_import_wallet_post_with_http_info(import_wallet_request, **kwargs)  # noqa: E501
        else:
            (data) = self.node_import_wallet_post_with_http_info(import_wallet_request, **kwargs)  # noqa: E501
            return data

    def node_import_wallet_post_with_http_info(self, import_wallet_request, **kwargs):  # noqa: E501
        """Import Wallet from a known secret key and authorization [async call]  # noqa: E501

        Import a Wallet into the Node under a specified ID; All the transactional history and outstanding balanced of the Wallet will be extracted from the Blockchain; The Wallet ID is required to be unique within the Node, but can otherwise be user-defined.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_import_wallet_post_with_http_info(import_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ImportWalletRequest import_wallet_request: (required)
        :return: AsyncTaskCreatedResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

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

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

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        # Authentication setting
        auth_settings = ['ApiKeyAuth']  # noqa: E501

        return self.api_client.call_api(
            '/node/import_wallet', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='AsyncTaskCreatedResponse',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

60676e70ccbac8d1bb36d397c99fb54423d099f5
<mask token>


class NodeApi(object):
    <mask token>
    <mask token>
    <mask token>
    <mask token>

    def node_cancel_task_post(self, task_action_request, **kwargs):
        """Cancel task with pending incoming transaction both incoming and outgoing [async call]  # noqa: E501

        A user may select to decline an incoming transaction. The related task will change its result to failure both on senders and the receivers side. This endpoint can also be used to cancel an outgoing pending transaction that is awaiting user interaction from the receiver  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_cancel_task_post(task_action_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param TaskActionRequest task_action_request: (required)
        :return: AsyncTaskCreatedResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_cancel_task_post_with_http_info(
                task_action_request, **kwargs)
        else:
            data = self.node_cancel_task_post_with_http_info(
                task_action_request, **kwargs)
            return data
    <mask token>

    def node_delete_wallet_post(self, delete_wallet_request, **kwargs):
        """Delete a Wallet [async call]  # noqa: E501

        Deletes a Wallet from the Node; All private information about the Wallet will be deleted including transactional history, balances, and keys; If the secret key of the Wallet are not stored elsewhere then all Assets held in the Wallet will be forever lost! If the secret key of the Wallet is stored elsewhere, then all held Assets and the entire transactional history of the Wallet can be restored from the Blockchain at any time by importing the Wallet into a Node.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_delete_wallet_post(delete_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteWalletRequest delete_wallet_request: (required)
        :return: AsyncTaskCreatedResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_delete_wallet_post_with_http_info(
                delete_wallet_request, **kwargs)
        else:
            data = self.node_delete_wallet_post_with_http_info(
                delete_wallet_request, **kwargs)
            return data

    def node_delete_wallet_post_with_http_info(self, delete_wallet_request,
        **kwargs):
        """Delete a Wallet [async call]  # noqa: E501

        Deletes a Wallet from the Node; All private information about the Wallet will be deleted including transactional history, balances, and keys; If the secret key of the Wallet are not stored elsewhere then all Assets held in the Wallet will be forever lost! If the secret key of the Wallet is stored elsewhere, then all held Assets and the entire transactional history of the Wallet can be restored from the Blockchain at any time by importing the Wallet into a Node.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_delete_wallet_post_with_http_info(delete_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteWalletRequest delete_wallet_request: (required)
        :return: AsyncTaskCreatedResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['delete_wallet_request']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')
        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s' to method node_delete_wallet_post"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if 'delete_wallet_request' not in local_var_params or local_var_params[
            'delete_wallet_request'] is None:
            raise ValueError(
                'Missing the required parameter `delete_wallet_request` when calling `node_delete_wallet_post`'
                )
        collection_formats = {}
        path_params = {}
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        if 'delete_wallet_request' in local_var_params:
            body_params = local_var_params['delete_wallet_request']
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        header_params['Content-Type'
            ] = self.api_client.select_header_content_type(['application/json']
            )
        auth_settings = ['ApiKeyAuth']
        return self.api_client.call_api('/node/delete_wallet', 'POST',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'AsyncTaskCreatedResponse', auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)
    <mask token>

    def node_export_auditor_access_wallet_post_with_http_info(self,
        export_auditor_access_wallet_request, **kwargs):
        """Export viewing credentials for a Wallet  # noqa: E501

        Export a viewing key that allows viewing all transactions to and from a wallet, including past transactions. The viewing key is encrypted for a specific Address, and can only be recovered by someone in possession of either a secret key or a viewing key for the Wallet that Address belongs to. The viewing key does enable making any transactions (including rule changes, issuance, and transfers) on behalf of the exported Wallet.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_export_auditor_access_wallet_post_with_http_info(export_auditor_access_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ExportAuditorAccessWalletRequest export_auditor_access_wallet_request: (required)
        :return: ExportAuditorAccessWalletResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['export_auditor_access_wallet_request']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')
        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s' to method node_export_auditor_access_wallet_post"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if ('export_auditor_access_wallet_request' not in local_var_params or
            local_var_params['export_auditor_access_wallet_request'] is None):
            raise ValueError(
                'Missing the required parameter `export_auditor_access_wallet_request` when calling `node_export_auditor_access_wallet_post`'
                )
        collection_formats = {}
        path_params = {}
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        if 'export_auditor_access_wallet_request' in local_var_params:
            body_params = local_var_params[
                'export_auditor_access_wallet_request']
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        header_params['Content-Type'
            ] = self.api_client.select_header_content_type(['application/json']
            )
        auth_settings = ['ApiKeyAuth']
        return self.api_client.call_api('/node/export_auditor_access_wallet',
            'POST', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='ExportAuditorAccessWalletResponse',
            auth_settings=auth_settings, async_req=local_var_params.get(
            'async_req'), _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def node_export_wallet_post(self, export_wallet_request, **kwargs):
        """Export wallet secret key  # noqa: E501

        Export an encrypted form of the Wallet's secret key; The authorization password under which the secret key is encrypted is the same one under which it was originally created or imported; Knowledge of the secret key and the authorization password is required to import the Wallet into a Node in the future.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_export_wallet_post(export_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ExportWalletRequest export_wallet_request: (required)
        :return: ExportWalletResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_export_wallet_post_with_http_info(
                export_wallet_request, **kwargs)
        else:
            data = self.node_export_wallet_post_with_http_info(
                export_wallet_request, **kwargs)
            return data
    <mask token>

    def node_generate_wallet_post(self, generate_wallet_request, **kwargs):
        """Generate a new Wallet  # noqa: E501

        Randomly generate a new Wallet under a specified ID; This only affects the Node and in particular nothing about this action is broadcast to the Blockchain; The Wallet ID is required to be unique within the Node, but can otherwise be user-defined.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_generate_wallet_post(generate_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GenerateWalletRequest generate_wallet_request: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_generate_wallet_post_with_http_info(
                generate_wallet_request, **kwargs)
        else:
            data = self.node_generate_wallet_post_with_http_info(
                generate_wallet_request, **kwargs)
            return data

    def node_generate_wallet_post_with_http_info(self,
        generate_wallet_request, **kwargs):
        """Generate a new Wallet  # noqa: E501

        Randomly generate a new Wallet under a specified ID; This only affects the Node and in particular nothing about this action is broadcast to the Blockchain; The Wallet ID is required to be unique within the Node, but can otherwise be user-defined.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_generate_wallet_post_with_http_info(generate_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GenerateWalletRequest generate_wallet_request: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['generate_wallet_request']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')
        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s' to method node_generate_wallet_post"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if ('generate_wallet_request' not in local_var_params or 
            local_var_params['generate_wallet_request'] is None):
            raise ValueError(
                'Missing the required parameter `generate_wallet_request` when calling `node_generate_wallet_post`'
                )
        collection_formats = {}
        path_params = {}
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        if 'generate_wallet_request' in local_var_params:
            body_params = local_var_params['generate_wallet_request']
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        header_params['Content-Type'
            ] = self.api_client.select_header_content_type(['application/json']
            )
        auth_settings = ['ApiKeyAuth']
        return self.api_client.call_api('/node/generate_wallet', 'POST',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            None, auth_settings=auth_settings, async_req=local_var_params.
            get('async_req'), _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def node_get_all_wallets_post(self, **kwargs):
        """Get all wallet IDs  # noqa: E501

        Returns a list of the IDs of all Wallets currently stored on the Node. Both full-access and view-only Wallets are listed.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_get_all_wallets_post(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :return: GetAllWalletsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_get_all_wallets_post_with_http_info(**kwargs)
        else:
            data = self.node_get_all_wallets_post_with_http_info(**kwargs)
            return data
    <mask token>
    <mask token>
    <mask token>

    def node_get_rules_post(self, **kwargs):
        """Get network governance Rules  # noqa: E501

        Returns a full list of all the Rules that govern admin and issuance rights within the network.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_get_rules_post(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :return: GetRulesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_get_rules_post_with_http_info(**kwargs)
        else:
            data = self.node_get_rules_post_with_http_info(**kwargs)
            return data
    <mask token>

    def node_get_task_status_post(self, get_task_status_request, **kwargs):
        """Get a specific task (by ID)  # noqa: E501

        Returns the meta-data of a given Task and its current status. The particular, private details of the Task such as an Asset ID or amount in a Transfer are not returned.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_get_task_status_post(get_task_status_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GetTaskStatusRequest get_task_status_request: (required)
        :return: GetTaskStatusResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_get_task_status_post_with_http_info(
                get_task_status_request, **kwargs)
        else:
            data = self.node_get_task_status_post_with_http_info(
                get_task_status_request, **kwargs)
            return data

    def node_get_task_status_post_with_http_info(self,
        get_task_status_request, **kwargs):
        """Get a specific task (by ID)  # noqa: E501

        Returns the meta-data of a given Task and its current status. The particular, private details of the Task such as an Asset ID or amount in a Transfer are not returned.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_get_task_status_post_with_http_info(get_task_status_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GetTaskStatusRequest get_task_status_request: (required)
        :return: GetTaskStatusResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['get_task_status_request']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')
        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s' to method node_get_task_status_post"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if ('get_task_status_request' not in local_var_params or 
            local_var_params['get_task_status_request'] is None):
            raise ValueError(
                'Missing the required parameter `get_task_status_request` when calling `node_get_task_status_post`'
                )
        collection_formats = {}
        path_params = {}
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        if 'get_task_status_request' in local_var_params:
            body_params = local_var_params['get_task_status_request']
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        header_params['Content-Type'
            ] = self.api_client.select_header_content_type(['application/json']
            )
        auth_settings = ['ApiKeyAuth']
        return self.api_client.call_api('/node/get_task_status', 'POST',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'GetTaskStatusResponse', auth_settings=auth_settings, async_req
            =local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def node_get_tasks_post(self, get_tasks_request, **kwargs):
        """Get a (potentially) filtered list of all Tasks  # noqa: E501

        Returns a list of all Tasks along with their meta-data and statuses. The particular, private details of the Task such as an Asset ID or amount in a Transfer are not returned. Tasks can be filtered using various parameters as specified in the request body.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_get_tasks_post(get_tasks_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GetTasksRequest get_tasks_request: (required)
        :return: GetTasksResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_get_tasks_post_with_http_info(get_tasks_request,
                **kwargs)
        else:
            data = self.node_get_tasks_post_with_http_info(get_tasks_request,
                **kwargs)
            return data
    <mask token>
    <mask token>
    <mask token>
    <mask token>
    <mask token>

<mask token>


class NodeApi(object):
    <mask token>

    def __init__(self, api_client=None):
        if api_client is None:
            api_client = ApiClient()
        self.api_client = api_client

    def node_approve_task_post(self, task_action_request, **kwargs):
        """Approve task with pending incoming transaction [async call]  # noqa: E501

        Confirmation request tasks are confirmed using this point. After the user confirms the incoming transaction, it is asynchronously sent to the blockchain and its status can be queried like any other async task.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_approve_task_post(task_action_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param TaskActionRequest task_action_request: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_approve_task_post_with_http_info(
                task_action_request, **kwargs)
        else:
            data = self.node_approve_task_post_with_http_info(
                task_action_request, **kwargs)
            return data
    <mask token>

    def node_cancel_task_post(self, task_action_request, **kwargs):
        """Cancel task with pending incoming transaction both incoming and outgoing [async call]  # noqa: E501

        A user may select to decline an incoming transaction. The related task will change its result to failure both on senders and the receivers side. This endpoint can also be used to cancel an outgoing pending transaction that is awaiting user interaction from the receiver  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_cancel_task_post(task_action_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param TaskActionRequest task_action_request: (required)
        :return: AsyncTaskCreatedResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_cancel_task_post_with_http_info(
                task_action_request, **kwargs)
        else:
            data = self.node_cancel_task_post_with_http_info(
                task_action_request, **kwargs)
            return data
    <mask token>

    def node_delete_wallet_post(self, delete_wallet_request, **kwargs):
        """Delete a Wallet [async call]  # noqa: E501

        Deletes a Wallet from the Node; All private information about the Wallet will be deleted including transactional history, balances, and keys; If the secret key of the Wallet are not stored elsewhere then all Assets held in the Wallet will be forever lost! If the secret key of the Wallet is stored elsewhere, then all held Assets and the entire transactional history of the Wallet can be restored from the Blockchain at any time by importing the Wallet into a Node.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_delete_wallet_post(delete_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteWalletRequest delete_wallet_request: (required)
        :return: AsyncTaskCreatedResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_delete_wallet_post_with_http_info(
                delete_wallet_request, **kwargs)
        else:
            data = self.node_delete_wallet_post_with_http_info(
                delete_wallet_request, **kwargs)
            return data

    def node_delete_wallet_post_with_http_info(self, delete_wallet_request,
        **kwargs):
        """Delete a Wallet [async call]  # noqa: E501

        Deletes a Wallet from the Node; All private information about the Wallet will be deleted including transactional history, balances, and keys; If the secret key of the Wallet are not stored elsewhere then all Assets held in the Wallet will be forever lost! If the secret key of the Wallet is stored elsewhere, then all held Assets and the entire transactional history of the Wallet can be restored from the Blockchain at any time by importing the Wallet into a Node.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_delete_wallet_post_with_http_info(delete_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteWalletRequest delete_wallet_request: (required)
        :return: AsyncTaskCreatedResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['delete_wallet_request']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')
        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s' to method node_delete_wallet_post"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if 'delete_wallet_request' not in local_var_params or local_var_params[
            'delete_wallet_request'] is None:
            raise ValueError(
                'Missing the required parameter `delete_wallet_request` when calling `node_delete_wallet_post`'
                )
        collection_formats = {}
        path_params = {}
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        if 'delete_wallet_request' in local_var_params:
            body_params = local_var_params['delete_wallet_request']
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        header_params['Content-Type'
            ] = self.api_client.select_header_content_type(['application/json']
            )
        auth_settings = ['ApiKeyAuth']
        return self.api_client.call_api('/node/delete_wallet', 'POST',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'AsyncTaskCreatedResponse', auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def node_export_auditor_access_wallet_post(self,
        export_auditor_access_wallet_request, **kwargs):
        """Export viewing credentials for a Wallet  # noqa: E501

        Export a viewing key that allows viewing all transactions to and from a wallet, including past transactions. The viewing key is encrypted for a specific Address, and can only be recovered by someone in possession of either a secret key or a viewing key for the Wallet that Address belongs to. The viewing key does enable making any transactions (including rule changes, issuance, and transfers) on behalf of the exported Wallet.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_export_auditor_access_wallet_post(export_auditor_access_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ExportAuditorAccessWalletRequest export_auditor_access_wallet_request: (required)
        :return: ExportAuditorAccessWalletResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_export_auditor_access_wallet_post_with_http_info(
                export_auditor_access_wallet_request, **kwargs)
        else:
            data = self.node_export_auditor_access_wallet_post_with_http_info(
                export_auditor_access_wallet_request, **kwargs)
            return data

    def node_export_auditor_access_wallet_post_with_http_info(self,
        export_auditor_access_wallet_request, **kwargs):
        """Export viewing credentials for a Wallet  # noqa: E501

        Export a viewing key that allows viewing all transactions to and from a wallet, including past transactions. The viewing key is encrypted for a specific Address, and can only be recovered by someone in possession of either a secret key or a viewing key for the Wallet that Address belongs to. The viewing key does enable making any transactions (including rule changes, issuance, and transfers) on behalf of the exported Wallet.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_export_auditor_access_wallet_post_with_http_info(export_auditor_access_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ExportAuditorAccessWalletRequest export_auditor_access_wallet_request: (required)
        :return: ExportAuditorAccessWalletResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['export_auditor_access_wallet_request']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')
        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s' to method node_export_auditor_access_wallet_post"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if ('export_auditor_access_wallet_request' not in local_var_params or
            local_var_params['export_auditor_access_wallet_request'] is None):
            raise ValueError(
                'Missing the required parameter `export_auditor_access_wallet_request` when calling `node_export_auditor_access_wallet_post`'
                )
        collection_formats = {}
        path_params = {}
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        if 'export_auditor_access_wallet_request' in local_var_params:
            body_params = local_var_params[
                'export_auditor_access_wallet_request']
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        header_params['Content-Type'
            ] = self.api_client.select_header_content_type(['application/json']
            )
        auth_settings = ['ApiKeyAuth']
        return self.api_client.call_api('/node/export_auditor_access_wallet',
            'POST', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='ExportAuditorAccessWalletResponse',
            auth_settings=auth_settings, async_req=local_var_params.get(
            'async_req'), _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def node_export_wallet_post(self, export_wallet_request, **kwargs):
        """Export wallet secret key  # noqa: E501

        Export an encrypted form of the Wallet's secret key; The authorization password under which the secret key is encrypted is the same one under which it was originally created or imported; Knowledge of the secret key and the authorization password is required to import the Wallet into a Node in the future.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_export_wallet_post(export_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ExportWalletRequest export_wallet_request: (required)
        :return: ExportWalletResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_export_wallet_post_with_http_info(
                export_wallet_request, **kwargs)
        else:
            data = self.node_export_wallet_post_with_http_info(
                export_wallet_request, **kwargs)
            return data

    def node_export_wallet_post_with_http_info(self, export_wallet_request,
        **kwargs):
        """Export wallet secret key  # noqa: E501

        Export an encrypted form of the Wallet's secret key; The authorization password under which the secret key is encrypted is the same one under which it was originally created or imported; Knowledge of the secret key and the authorization password is required to import the Wallet into a Node in the future.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_export_wallet_post_with_http_info(export_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ExportWalletRequest export_wallet_request: (required)
        :return: ExportWalletResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['export_wallet_request']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')
        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s' to method node_export_wallet_post"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if 'export_wallet_request' not in local_var_params or local_var_params[
            'export_wallet_request'] is None:
            raise ValueError(
                'Missing the required parameter `export_wallet_request` when calling `node_export_wallet_post`'
                )
        collection_formats = {}
        path_params = {}
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        if 'export_wallet_request' in local_var_params:
            body_params = local_var_params['export_wallet_request']
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        header_params['Content-Type'
            ] = self.api_client.select_header_content_type(['application/json']
            )
        auth_settings = ['ApiKeyAuth']
        return self.api_client.call_api('/node/export_wallet', 'POST',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'ExportWalletResponse', auth_settings=auth_settings, async_req=
            local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def node_generate_wallet_post(self, generate_wallet_request, **kwargs):
        """Generate a new Wallet  # noqa: E501

        Randomly generate a new Wallet under a specified ID; This only affects the Node and in particular nothing about this action is broadcast to the Blockchain; The Wallet ID is required to be unique within the Node, but can otherwise be user-defined.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_generate_wallet_post(generate_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GenerateWalletRequest generate_wallet_request: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_generate_wallet_post_with_http_info(
                generate_wallet_request, **kwargs)
        else:
            data = self.node_generate_wallet_post_with_http_info(
                generate_wallet_request, **kwargs)
            return data

    def node_generate_wallet_post_with_http_info(self,
        generate_wallet_request, **kwargs):
        """Generate a new Wallet  # noqa: E501

        Randomly generate a new Wallet under a specified ID; This only affects the Node and in particular nothing about this action is broadcast to the Blockchain; The Wallet ID is required to be unique within the Node, but can otherwise be user-defined.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_generate_wallet_post_with_http_info(generate_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GenerateWalletRequest generate_wallet_request: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['generate_wallet_request']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')
        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s' to method node_generate_wallet_post"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if ('generate_wallet_request' not in local_var_params or 
            local_var_params['generate_wallet_request'] is None):
            raise ValueError(
                'Missing the required parameter `generate_wallet_request` when calling `node_generate_wallet_post`'
                )
        collection_formats = {}
        path_params = {}
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        if 'generate_wallet_request' in local_var_params:
            body_params = local_var_params['generate_wallet_request']
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        header_params['Content-Type'
            ] = self.api_client.select_header_content_type(['application/json']
            )
        auth_settings = ['ApiKeyAuth']
        return self.api_client.call_api('/node/generate_wallet', 'POST',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            None, auth_settings=auth_settings, async_req=local_var_params.
            get('async_req'), _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def node_get_all_wallets_post(self, **kwargs):
        """Get all wallet IDs  # noqa: E501

        Returns a list of the IDs of all Wallets currently stored on the Node. Both full-access and view-only Wallets are listed.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_get_all_wallets_post(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :return: GetAllWalletsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_get_all_wallets_post_with_http_info(**kwargs)
        else:
            data = self.node_get_all_wallets_post_with_http_info(**kwargs)
            return data

    def node_get_all_wallets_post_with_http_info(self, **kwargs):
        """Get all wallet IDs  # noqa: E501

        Returns a list of the IDs of all Wallets currently stored on the Node. Both full-access and view-only Wallets are listed.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_get_all_wallets_post_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :return: GetAllWalletsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = []
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')
        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s' to method node_get_all_wallets_post"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        collection_formats = {}
        path_params = {}
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['ApiKeyAuth']
        return self.api_client.call_api('/node/get_all_wallets', 'POST',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'GetAllWalletsResponse', auth_settings=auth_settings, async_req
            =local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def node_get_notifications_post(self, get_notifications_request, **kwargs):
        """Get notifications  # noqa: E501

        Notifications are the Node's way to report about recent activity and status changes. This endpoint allows polling for these changes and fetching the updates. The notifications can be filtered in multiple ways.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_get_notifications_post(get_notifications_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GetNotificationsRequest get_notifications_request: (required)
        :return: GetNotificationsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_get_notifications_post_with_http_info(
                get_notifications_request, **kwargs)
        else:
            data = self.node_get_notifications_post_with_http_info(
                get_notifications_request, **kwargs)
            return data

    def node_get_notifications_post_with_http_info(self,
        get_notifications_request, **kwargs):
        """Get notifications  # noqa: E501

        Notifications are the Node's way to report about recent activity and status changes. This endpoint allows polling for these changes and fetching the updates. The notifications can be filtered in multiple ways.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_get_notifications_post_with_http_info(get_notifications_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GetNotificationsRequest get_notifications_request: (required)
        :return: GetNotificationsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['get_notifications_request']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')
        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s' to method node_get_notifications_post"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if ('get_notifications_request' not in local_var_params or 
            local_var_params['get_notifications_request'] is None):
            raise ValueError(
                'Missing the required parameter `get_notifications_request` when calling `node_get_notifications_post`'
                )
        collection_formats = {}
        path_params = {}
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        if 'get_notifications_request' in local_var_params:
            body_params = local_var_params['get_notifications_request']
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        header_params['Content-Type'
            ] = self.api_client.select_header_content_type(['application/json']
            )
        auth_settings = ['ApiKeyAuth']
        return self.api_client.call_api('/node/get_notifications', 'POST',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'GetNotificationsResponse', auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def node_get_rules_post(self, **kwargs):
        """Get network governance Rules  # noqa: E501

        Returns a full list of all the Rules that govern admin and issuance rights within the network.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_get_rules_post(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :return: GetRulesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_get_rules_post_with_http_info(**kwargs)
        else:
            data = self.node_get_rules_post_with_http_info(**kwargs)
            return data

    def node_get_rules_post_with_http_info(self, **kwargs):
        """Get network governance Rules  # noqa: E501

        Returns a full list of all the Rules that govern admin and issuance rights within the network.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_get_rules_post_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :return: GetRulesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = []
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')
        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s' to method node_get_rules_post"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        collection_formats = {}
        path_params = {}
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['ApiKeyAuth']
        return self.api_client.call_api('/node/get_rules', 'POST',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'GetRulesResponse', auth_settings=auth_settings, async_req=
            local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def node_get_task_status_post(self, get_task_status_request, **kwargs):
        """Get a specific task (by ID)  # noqa: E501

        Returns the meta-data of a given Task and its current status. The particular, private details of the Task such as an Asset ID or amount in a Transfer are not returned.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_get_task_status_post(get_task_status_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GetTaskStatusRequest get_task_status_request: (required)
        :return: GetTaskStatusResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_get_task_status_post_with_http_info(
                get_task_status_request, **kwargs)
        else:
            data = self.node_get_task_status_post_with_http_info(
                get_task_status_request, **kwargs)
            return data

    def node_get_task_status_post_with_http_info(self,
        get_task_status_request, **kwargs):
        """Get a specific task (by ID)  # noqa: E501

        Returns the meta-data of a given Task and its current status. The particular, private details of the Task such as an Asset ID or amount in a Transfer are not returned.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_get_task_status_post_with_http_info(get_task_status_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GetTaskStatusRequest get_task_status_request: (required)
        :return: GetTaskStatusResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['get_task_status_request']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')
        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s' to method node_get_task_status_post"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if ('get_task_status_request' not in local_var_params or 
            local_var_params['get_task_status_request'] is None):
            raise ValueError(
                'Missing the required parameter `get_task_status_request` when calling `node_get_task_status_post`'
                )
        collection_formats = {}
        path_params = {}
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        if 'get_task_status_request' in local_var_params:
            body_params = local_var_params['get_task_status_request']
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        header_params['Content-Type'
            ] = self.api_client.select_header_content_type(['application/json']
            )
        auth_settings = ['ApiKeyAuth']
        return self.api_client.call_api('/node/get_task_status', 'POST',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'GetTaskStatusResponse', auth_settings=auth_settings, async_req
            =local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def node_get_tasks_post(self, get_tasks_request, **kwargs):
        """Get a (potentially) filtered list of all Tasks  # noqa: E501

        Returns a list of all Tasks along with their meta-data and statuses. The particular, private details of the Task such as an Asset ID or amount in a Transfer are not returned. Tasks can be filtered using various parameters as specified in the request body.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_get_tasks_post(get_tasks_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GetTasksRequest get_tasks_request: (required)
        :return: GetTasksResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_get_tasks_post_with_http_info(get_tasks_request,
                **kwargs)
        else:
            data = self.node_get_tasks_post_with_http_info(get_tasks_request,
                **kwargs)
            return data
    <mask token>
    <mask token>

    def node_import_auditor_access_wallet_post_with_http_info(self,
        import_auditor_access_wallet_request, **kwargs):
        """Import viewing credentials for a Wallet [async call]  # noqa: E501

        Import a viewing key generated by the export_auditor_access_wallet endpoint. This will create a read-only wallet which can be queried with endpoints such as get_activity and get_balances, but cannot be used to perform transactions. The Wallet whose Address was used as the recipient for the exported viewing key must already be imported within the Node in order for this process to succeed.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_import_auditor_access_wallet_post_with_http_info(import_auditor_access_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ImportAuditorAccessWalletRequest import_auditor_access_wallet_request: (required)
        :return: AsyncTaskCreatedResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['import_auditor_access_wallet_request']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')
        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s' to method node_import_auditor_access_wallet_post"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if ('import_auditor_access_wallet_request' not in local_var_params or
            local_var_params['import_auditor_access_wallet_request'] is None):
            raise ValueError(
                'Missing the required parameter `import_auditor_access_wallet_request` when calling `node_import_auditor_access_wallet_post`'
                )
        collection_formats = {}
        path_params = {}
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        if 'import_auditor_access_wallet_request' in local_var_params:
            body_params = local_var_params[
                'import_auditor_access_wallet_request']
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        header_params['Content-Type'
            ] = self.api_client.select_header_content_type(['application/json']
            )
        auth_settings = ['ApiKeyAuth']
        return self.api_client.call_api('/node/import_auditor_access_wallet',
            'POST', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='AsyncTaskCreatedResponse', auth_settings=
            auth_settings, async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def node_import_wallet_post(self, import_wallet_request, **kwargs):
        """Import Wallet from a known secret key and authorization [async call]  # noqa: E501

        Import a Wallet into the Node under a specified ID; All the transactional history and outstanding balanced of the Wallet will be extracted from the Blockchain; The Wallet ID is required to be unique within the Node, but can otherwise be user-defined.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_import_wallet_post(import_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ImportWalletRequest import_wallet_request: (required)
        :return: AsyncTaskCreatedResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_import_wallet_post_with_http_info(
                import_wallet_request, **kwargs)
        else:
            data = self.node_import_wallet_post_with_http_info(
                import_wallet_request, **kwargs)
            return data
    <mask token>

<mask token>


class NodeApi(object):
    <mask token>

    def __init__(self, api_client=None):
        if api_client is None:
            api_client = ApiClient()
        self.api_client = api_client

    def node_approve_task_post(self, task_action_request, **kwargs):
        """Approve task with pending incoming transaction [async call]  # noqa: E501

        Confirmation request tasks are confirmed using this point. After the user confirms the incoming transaction, it is asynchronously sent to the blockchain and its status can be queried like any other async task.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_approve_task_post(task_action_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param TaskActionRequest task_action_request: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_approve_task_post_with_http_info(
                task_action_request, **kwargs)
        else:
            data = self.node_approve_task_post_with_http_info(
                task_action_request, **kwargs)
            return data
    <mask token>

    def node_cancel_task_post(self, task_action_request, **kwargs):
        """Cancel task with pending incoming transaction both incoming and outgoing [async call]  # noqa: E501

        A user may select to decline an incoming transaction. The related task will change its result to failure both on senders and the receivers side. This endpoint can also be used to cancel an outgoing pending transaction that is awaiting user interaction from the receiver  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_cancel_task_post(task_action_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param TaskActionRequest task_action_request: (required)
        :return: AsyncTaskCreatedResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_cancel_task_post_with_http_info(
                task_action_request, **kwargs)
        else:
            data = self.node_cancel_task_post_with_http_info(
                task_action_request, **kwargs)
            return data

    def node_cancel_task_post_with_http_info(self, task_action_request, **
        kwargs):
        """Cancel task with pending incoming transaction both incoming and outgoing [async call]  # noqa: E501

        A user may select to decline an incoming transaction. The related task will change its result to failure both on senders and the receivers side. This endpoint can also be used to cancel an outgoing pending transaction that is awaiting user interaction from the receiver  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_cancel_task_post_with_http_info(task_action_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param TaskActionRequest task_action_request: (required)
        :return: AsyncTaskCreatedResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['task_action_request']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')
        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s' to method node_cancel_task_post"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if 'task_action_request' not in local_var_params or local_var_params[
            'task_action_request'] is None:
            raise ValueError(
                'Missing the required parameter `task_action_request` when calling `node_cancel_task_post`'
                )
        collection_formats = {}
        path_params = {}
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        if 'task_action_request' in local_var_params:
            body_params = local_var_params['task_action_request']
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        header_params['Content-Type'
            ] = self.api_client.select_header_content_type(['application/json']
            )
        auth_settings = ['ApiKeyAuth']
        return self.api_client.call_api('/node/cancel_task', 'POST',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'AsyncTaskCreatedResponse', auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def node_delete_wallet_post(self, delete_wallet_request, **kwargs):
        """Delete a Wallet [async call]  # noqa: E501

        Deletes a Wallet from the Node; All private information about the Wallet will be deleted including transactional history, balances, and keys; If the secret key of the Wallet are not stored elsewhere then all Assets held in the Wallet will be forever lost! If the secret key of the Wallet is stored elsewhere, then all held Assets and the entire transactional history of the Wallet can be restored from the Blockchain at any time by importing the Wallet into a Node.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_delete_wallet_post(delete_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteWalletRequest delete_wallet_request: (required)
        :return: AsyncTaskCreatedResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_delete_wallet_post_with_http_info(
                delete_wallet_request, **kwargs)
        else:
            data = self.node_delete_wallet_post_with_http_info(
                delete_wallet_request, **kwargs)
            return data

    def node_delete_wallet_post_with_http_info(self, delete_wallet_request,
        **kwargs):
        """Delete a Wallet [async call]  # noqa: E501

        Deletes a Wallet from the Node; All private information about the Wallet will be deleted including transactional history, balances, and keys; If the secret key of the Wallet are not stored elsewhere then all Assets held in the Wallet will be forever lost! If the secret key of the Wallet is stored elsewhere, then all held Assets and the entire transactional history of the Wallet can be restored from the Blockchain at any time by importing the Wallet into a Node.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_delete_wallet_post_with_http_info(delete_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteWalletRequest delete_wallet_request: (required)
        :return: AsyncTaskCreatedResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['delete_wallet_request']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')
        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s' to method node_delete_wallet_post"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if 'delete_wallet_request' not in local_var_params or local_var_params[
            'delete_wallet_request'] is None:
            raise ValueError(
                'Missing the required parameter `delete_wallet_request` when calling `node_delete_wallet_post`'
                )
        collection_formats = {}
        path_params = {}
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        if 'delete_wallet_request' in local_var_params:
            body_params = local_var_params['delete_wallet_request']
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        header_params['Content-Type'
            ] = self.api_client.select_header_content_type(['application/json']
            )
        auth_settings = ['ApiKeyAuth']
        return self.api_client.call_api('/node/delete_wallet', 'POST',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'AsyncTaskCreatedResponse', auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def node_export_auditor_access_wallet_post(self,
        export_auditor_access_wallet_request, **kwargs):
        """Export viewing credentials for a Wallet  # noqa: E501

        Export a viewing key that allows viewing all transactions to and from a wallet, including past transactions. The viewing key is encrypted for a specific Address, and can only be recovered by someone in possession of either a secret key or a viewing key for the Wallet that Address belongs to. The viewing key does enable making any transactions (including rule changes, issuance, and transfers) on behalf of the exported Wallet.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_export_auditor_access_wallet_post(export_auditor_access_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ExportAuditorAccessWalletRequest export_auditor_access_wallet_request: (required)
        :return: ExportAuditorAccessWalletResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_export_auditor_access_wallet_post_with_http_info(
                export_auditor_access_wallet_request, **kwargs)
        else:
            data = self.node_export_auditor_access_wallet_post_with_http_info(
                export_auditor_access_wallet_request, **kwargs)
            return data

    def node_export_auditor_access_wallet_post_with_http_info(self,
        export_auditor_access_wallet_request, **kwargs):
        """Export viewing credentials for a Wallet  # noqa: E501

        Export a viewing key that allows viewing all transactions to and from a wallet, including past transactions. The viewing key is encrypted for a specific Address, and can only be recovered by someone in possession of either a secret key or a viewing key for the Wallet that Address belongs to. The viewing key does enable making any transactions (including rule changes, issuance, and transfers) on behalf of the exported Wallet.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_export_auditor_access_wallet_post_with_http_info(export_auditor_access_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ExportAuditorAccessWalletRequest export_auditor_access_wallet_request: (required)
        :return: ExportAuditorAccessWalletResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['export_auditor_access_wallet_request']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')
        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s' to method node_export_auditor_access_wallet_post"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if ('export_auditor_access_wallet_request' not in local_var_params or
            local_var_params['export_auditor_access_wallet_request'] is None):
            raise ValueError(
                'Missing the required parameter `export_auditor_access_wallet_request` when calling `node_export_auditor_access_wallet_post`'
                )
        collection_formats = {}
        path_params = {}
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        if 'export_auditor_access_wallet_request' in local_var_params:
            body_params = local_var_params[
                'export_auditor_access_wallet_request']
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        header_params['Content-Type'
            ] = self.api_client.select_header_content_type(['application/json']
            )
        auth_settings = ['ApiKeyAuth']
        return self.api_client.call_api('/node/export_auditor_access_wallet',
            'POST', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='ExportAuditorAccessWalletResponse',
            auth_settings=auth_settings, async_req=local_var_params.get(
            'async_req'), _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def node_export_wallet_post(self, export_wallet_request, **kwargs):
        """Export wallet secret key  # noqa: E501

        Export an encrypted form of the Wallet's secret key; The authorization password under which the secret key is encrypted is the same one under which it was originally created or imported; Knowledge of the secret key and the authorization password is required to import the Wallet into a Node in the future.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_export_wallet_post(export_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ExportWalletRequest export_wallet_request: (required)
        :return: ExportWalletResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_export_wallet_post_with_http_info(
                export_wallet_request, **kwargs)
        else:
            data = self.node_export_wallet_post_with_http_info(
                export_wallet_request, **kwargs)
            return data

    def node_export_wallet_post_with_http_info(self, export_wallet_request,
        **kwargs):
        """Export wallet secret key  # noqa: E501

        Export an encrypted form of the Wallet's secret key; The authorization password under which the secret key is encrypted is the same one under which it was originally created or imported; Knowledge of the secret key and the authorization password is required to import the Wallet into a Node in the future.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_export_wallet_post_with_http_info(export_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ExportWalletRequest export_wallet_request: (required)
        :return: ExportWalletResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['export_wallet_request']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')
        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s' to method node_export_wallet_post"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if 'export_wallet_request' not in local_var_params or local_var_params[
            'export_wallet_request'] is None:
            raise ValueError(
                'Missing the required parameter `export_wallet_request` when calling `node_export_wallet_post`'
                )
        collection_formats = {}
        path_params = {}
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        if 'export_wallet_request' in local_var_params:
            body_params = local_var_params['export_wallet_request']
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        header_params['Content-Type'
            ] = self.api_client.select_header_content_type(['application/json']
            )
        auth_settings = ['ApiKeyAuth']
        return self.api_client.call_api('/node/export_wallet', 'POST',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'ExportWalletResponse', auth_settings=auth_settings, async_req=
            local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def node_generate_wallet_post(self, generate_wallet_request, **kwargs):
        """Generate a new Wallet  # noqa: E501

        Randomly generate a new Wallet under a specified ID; This only affects the Node and in particular nothing about this action is broadcast to the Blockchain; The Wallet ID is required to be unique within the Node, but can otherwise be user-defined.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_generate_wallet_post(generate_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GenerateWalletRequest generate_wallet_request: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_generate_wallet_post_with_http_info(
                generate_wallet_request, **kwargs)
        else:
            data = self.node_generate_wallet_post_with_http_info(
                generate_wallet_request, **kwargs)
            return data

    def node_generate_wallet_post_with_http_info(self,
        generate_wallet_request, **kwargs):
        """Generate a new Wallet  # noqa: E501

        Randomly generate a new Wallet under a specified ID; This only affects the Node and in particular nothing about this action is broadcast to the Blockchain; The Wallet ID is required to be unique within the Node, but can otherwise be user-defined.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_generate_wallet_post_with_http_info(generate_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GenerateWalletRequest generate_wallet_request: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['generate_wallet_request']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')
        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s' to method node_generate_wallet_post"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if ('generate_wallet_request' not in local_var_params or 
            local_var_params['generate_wallet_request'] is None):
            raise ValueError(
                'Missing the required parameter `generate_wallet_request` when calling `node_generate_wallet_post`'
                )
        collection_formats = {}
        path_params = {}
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        if 'generate_wallet_request' in local_var_params:
            body_params = local_var_params['generate_wallet_request']
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        header_params['Content-Type'
            ] = self.api_client.select_header_content_type(['application/json']
            )
        auth_settings = ['ApiKeyAuth']
        return self.api_client.call_api('/node/generate_wallet', 'POST',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            None, auth_settings=auth_settings, async_req=local_var_params.
            get('async_req'), _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def node_get_all_wallets_post(self, **kwargs):
        """Get all wallet IDs  # noqa: E501

        Returns a list of the IDs of all Wallets currently stored on the Node. Both full-access and view-only Wallets are listed.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_get_all_wallets_post(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :return: GetAllWalletsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_get_all_wallets_post_with_http_info(**kwargs)
        else:
            data = self.node_get_all_wallets_post_with_http_info(**kwargs)
            return data

    def node_get_all_wallets_post_with_http_info(self, **kwargs):
        """Get all wallet IDs  # noqa: E501

        Returns a list of the IDs of all Wallets currently stored on the Node. Both full-access and view-only Wallets are listed.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_get_all_wallets_post_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :return: GetAllWalletsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = []
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')
        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s' to method node_get_all_wallets_post"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        collection_formats = {}
        path_params = {}
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['ApiKeyAuth']
        return self.api_client.call_api('/node/get_all_wallets', 'POST',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'GetAllWalletsResponse', auth_settings=auth_settings, async_req
            =local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def node_get_notifications_post(self, get_notifications_request, **kwargs):
        """Get notifications  # noqa: E501

        Notifications are the Node's way to report about recent activity and status changes. This endpoint allows polling for these changes and fetching the updates. The notifications can be filtered in multiple ways.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_get_notifications_post(get_notifications_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GetNotificationsRequest get_notifications_request: (required)
        :return: GetNotificationsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_get_notifications_post_with_http_info(
                get_notifications_request, **kwargs)
        else:
            data = self.node_get_notifications_post_with_http_info(
                get_notifications_request, **kwargs)
            return data

    def node_get_notifications_post_with_http_info(self,
        get_notifications_request, **kwargs):
        """Get notifications  # noqa: E501

        Notifications are the Node's way to report about recent activity and status changes. This endpoint allows polling for these changes and fetching the updates. The notifications can be filtered in multiple ways.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_get_notifications_post_with_http_info(get_notifications_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GetNotificationsRequest get_notifications_request: (required)
        :return: GetNotificationsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['get_notifications_request']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')
        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s' to method node_get_notifications_post"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if ('get_notifications_request' not in local_var_params or 
            local_var_params['get_notifications_request'] is None):
            raise ValueError(
                'Missing the required parameter `get_notifications_request` when calling `node_get_notifications_post`'
                )
        collection_formats = {}
        path_params = {}
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        if 'get_notifications_request' in local_var_params:
            body_params = local_var_params['get_notifications_request']
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        header_params['Content-Type'
            ] = self.api_client.select_header_content_type(['application/json']
            )
        auth_settings = ['ApiKeyAuth']
        return self.api_client.call_api('/node/get_notifications', 'POST',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'GetNotificationsResponse', auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def node_get_rules_post(self, **kwargs):
        """Get network governance Rules  # noqa: E501

        Returns a full list of all the Rules that govern admin and issuance rights within the network.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_get_rules_post(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :return: GetRulesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_get_rules_post_with_http_info(**kwargs)
        else:
            data = self.node_get_rules_post_with_http_info(**kwargs)
            return data

    def node_get_rules_post_with_http_info(self, **kwargs):
        """Get network governance Rules  # noqa: E501

        Returns a full list of all the Rules that govern admin and issuance rights within the network.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_get_rules_post_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :return: GetRulesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = []
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')
        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s' to method node_get_rules_post"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        collection_formats = {}
        path_params = {}
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['ApiKeyAuth']
        return self.api_client.call_api('/node/get_rules', 'POST',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'GetRulesResponse', auth_settings=auth_settings, async_req=
            local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def node_get_task_status_post(self, get_task_status_request, **kwargs):
        """Get a specific task (by ID)  # noqa: E501

        Returns the meta-data of a given Task and its current status. The particular, private details of the Task such as an Asset ID or amount in a Transfer are not returned.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_get_task_status_post(get_task_status_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GetTaskStatusRequest get_task_status_request: (required)
        :return: GetTaskStatusResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_get_task_status_post_with_http_info(
                get_task_status_request, **kwargs)
        else:
            data = self.node_get_task_status_post_with_http_info(
                get_task_status_request, **kwargs)
            return data

    def node_get_task_status_post_with_http_info(self,
        get_task_status_request, **kwargs):
        """Get a specific task (by ID)  # noqa: E501

        Returns the meta-data of a given Task and its current status. The particular, private details of the Task such as an Asset ID or amount in a Transfer are not returned.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_get_task_status_post_with_http_info(get_task_status_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GetTaskStatusRequest get_task_status_request: (required)
        :return: GetTaskStatusResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['get_task_status_request']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')
        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s' to method node_get_task_status_post"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if ('get_task_status_request' not in local_var_params or 
            local_var_params['get_task_status_request'] is None):
            raise ValueError(
                'Missing the required parameter `get_task_status_request` when calling `node_get_task_status_post`'
                )
        collection_formats = {}
        path_params = {}
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        if 'get_task_status_request' in local_var_params:
            body_params = local_var_params['get_task_status_request']
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        header_params['Content-Type'
            ] = self.api_client.select_header_content_type(['application/json']
            )
        auth_settings = ['ApiKeyAuth']
        return self.api_client.call_api('/node/get_task_status', 'POST',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'GetTaskStatusResponse', auth_settings=auth_settings, async_req
            =local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def node_get_tasks_post(self, get_tasks_request, **kwargs):
        """Get a (potentially) filtered list of all Tasks  # noqa: E501

        Returns a list of all Tasks along with their meta-data and statuses. The particular, private details of the Task such as an Asset ID or amount in a Transfer are not returned. Tasks can be filtered using various parameters as specified in the request body.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_get_tasks_post(get_tasks_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GetTasksRequest get_tasks_request: (required)
        :return: GetTasksResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_get_tasks_post_with_http_info(get_tasks_request,
                **kwargs)
        else:
            data = self.node_get_tasks_post_with_http_info(get_tasks_request,
                **kwargs)
            return data

    def node_get_tasks_post_with_http_info(self, get_tasks_request, **kwargs):
        """Get a (potentially) filtered list of all Tasks  # noqa: E501

        Returns a list of all Tasks along with their meta-data and statuses. The particular, private details of the Task such as an Asset ID or amount in a Transfer are not returned. Tasks can be filtered using various parameters as specified in the request body.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_get_tasks_post_with_http_info(get_tasks_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GetTasksRequest get_tasks_request: (required)
        :return: GetTasksResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['get_tasks_request']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')
        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s' to method node_get_tasks_post"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if 'get_tasks_request' not in local_var_params or local_var_params[
            'get_tasks_request'] is None:
            raise ValueError(
                'Missing the required parameter `get_tasks_request` when calling `node_get_tasks_post`'
                )
        collection_formats = {}
        path_params = {}
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        if 'get_tasks_request' in local_var_params:
            body_params = local_var_params['get_tasks_request']
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        header_params['Content-Type'
            ] = self.api_client.select_header_content_type(['application/json']
            )
        auth_settings = ['ApiKeyAuth']
        return self.api_client.call_api('/node/get_tasks', 'POST',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'GetTasksResponse', auth_settings=auth_settings, async_req=
            local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def node_import_auditor_access_wallet_post(self,
        import_auditor_access_wallet_request, **kwargs):
        """Import viewing credentials for a Wallet [async call]  # noqa: E501

        Import a viewing key generated by the export_auditor_access_wallet endpoint. This will create a read-only wallet which can be queried with endpoints such as get_activity and get_balances, but cannot be used to perform transactions. The Wallet whose Address was used as the recipient for the exported viewing key must already be imported within the Node in order for this process to succeed.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_import_auditor_access_wallet_post(import_auditor_access_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ImportAuditorAccessWalletRequest import_auditor_access_wallet_request: (required)
        :return: AsyncTaskCreatedResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_import_auditor_access_wallet_post_with_http_info(
                import_auditor_access_wallet_request, **kwargs)
        else:
            data = self.node_import_auditor_access_wallet_post_with_http_info(
                import_auditor_access_wallet_request, **kwargs)
            return data

    def node_import_auditor_access_wallet_post_with_http_info(self,
        import_auditor_access_wallet_request, **kwargs):
        """Import viewing credentials for a Wallet [async call]  # noqa: E501

        Import a viewing key generated by the export_auditor_access_wallet endpoint. This will create a read-only wallet which can be queried with endpoints such as get_activity and get_balances, but cannot be used to perform transactions. The Wallet whose Address was used as the recipient for the exported viewing key must already be imported within the Node in order for this process to succeed.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_import_auditor_access_wallet_post_with_http_info(import_auditor_access_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ImportAuditorAccessWalletRequest import_auditor_access_wallet_request: (required)
        :return: AsyncTaskCreatedResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['import_auditor_access_wallet_request']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')
        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s' to method node_import_auditor_access_wallet_post"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if ('import_auditor_access_wallet_request' not in local_var_params or
            local_var_params['import_auditor_access_wallet_request'] is None):
            raise ValueError(
                'Missing the required parameter `import_auditor_access_wallet_request` when calling `node_import_auditor_access_wallet_post`'
                )
        collection_formats = {}
        path_params = {}
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        if 'import_auditor_access_wallet_request' in local_var_params:
            body_params = local_var_params[
                'import_auditor_access_wallet_request']
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        header_params['Content-Type'
            ] = self.api_client.select_header_content_type(['application/json']
            )
        auth_settings = ['ApiKeyAuth']
        return self.api_client.call_api('/node/import_auditor_access_wallet',
            'POST', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='AsyncTaskCreatedResponse', auth_settings=
            auth_settings, async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def node_import_wallet_post(self, import_wallet_request, **kwargs):
        """Import Wallet from a known secret key and authorization [async call]  # noqa: E501

        Import a Wallet into the Node under a specified ID; All the transactional history and outstanding balanced of the Wallet will be extracted from the Blockchain; The Wallet ID is required to be unique within the Node, but can otherwise be user-defined.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_import_wallet_post(import_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ImportWalletRequest import_wallet_request: (required)
        :return: AsyncTaskCreatedResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_import_wallet_post_with_http_info(
                import_wallet_request, **kwargs)
        else:
            data = self.node_import_wallet_post_with_http_info(
                import_wallet_request, **kwargs)
            return data

    def node_import_wallet_post_with_http_info(self, import_wallet_request,
        **kwargs):
        """Import Wallet from a known secret key and authorization [async call]  # noqa: E501

        Import a Wallet into the Node under a specified ID; All the transactional history and outstanding balanced of the Wallet will be extracted from the Blockchain; The Wallet ID is required to be unique within the Node, but can otherwise be user-defined.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_import_wallet_post_with_http_info(import_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ImportWalletRequest import_wallet_request: (required)
        :return: AsyncTaskCreatedResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['import_wallet_request']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')
        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s' to method node_import_wallet_post"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if 'import_wallet_request' not in local_var_params or local_var_params[
            'import_wallet_request'] is None:
            raise ValueError(
                'Missing the required parameter `import_wallet_request` when calling `node_import_wallet_post`'
                )
        collection_formats = {}
        path_params = {}
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        if 'import_wallet_request' in local_var_params:
            body_params = local_var_params['import_wallet_request']
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        header_params['Content-Type'
            ] = self.api_client.select_header_content_type(['application/json']
            )
        auth_settings = ['ApiKeyAuth']
        return self.api_client.call_api('/node/import_wallet', 'POST',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'AsyncTaskCreatedResponse', auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

<mask token>


class NodeApi(object):
    <mask token>

    def __init__(self, api_client=None):
        if api_client is None:
            api_client = ApiClient()
        self.api_client = api_client

    def node_approve_task_post(self, task_action_request, **kwargs):
        """Approve task with pending incoming transaction [async call]  # noqa: E501

        Confirmation request tasks are confirmed using this point. After the user confirms the incoming transaction, it is asynchronously sent to the blockchain and its status can be queried like any other async task.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_approve_task_post(task_action_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param TaskActionRequest task_action_request: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_approve_task_post_with_http_info(
                task_action_request, **kwargs)
        else:
            data = self.node_approve_task_post_with_http_info(
                task_action_request, **kwargs)
            return data

    def node_approve_task_post_with_http_info(self, task_action_request, **
        kwargs):
        """Approve task with pending incoming transaction [async call]  # noqa: E501

        Confirmation request tasks are confirmed using this point. After the user confirms the incoming transaction, it is asynchronously sent to the blockchain and its status can be queried like any other async task.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_approve_task_post_with_http_info(task_action_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param TaskActionRequest task_action_request: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['task_action_request']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')
        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s' to method node_approve_task_post"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if 'task_action_request' not in local_var_params or local_var_params[
            'task_action_request'] is None:
            raise ValueError(
                'Missing the required parameter `task_action_request` when calling `node_approve_task_post`'
                )
        collection_formats = {}
        path_params = {}
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        if 'task_action_request' in local_var_params:
            body_params = local_var_params['task_action_request']
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        header_params['Content-Type'
            ] = self.api_client.select_header_content_type(['application/json']
            )
        auth_settings = ['ApiKeyAuth']
        return self.api_client.call_api('/node/approve_task', 'POST',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            None, auth_settings=auth_settings, async_req=local_var_params.
            get('async_req'), _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def node_cancel_task_post(self, task_action_request, **kwargs):
        """Cancel task with pending incoming transaction both incoming and outgoing [async call]  # noqa: E501

        A user may select to decline an incoming transaction. The related task will change its result to failure both on senders and the receivers side. This endpoint can also be used to cancel an outgoing pending transaction that is awaiting user interaction from the receiver  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_cancel_task_post(task_action_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param TaskActionRequest task_action_request: (required)
        :return: AsyncTaskCreatedResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_cancel_task_post_with_http_info(
                task_action_request, **kwargs)
        else:
            data = self.node_cancel_task_post_with_http_info(
                task_action_request, **kwargs)
            return data

    def node_cancel_task_post_with_http_info(self, task_action_request, **
        kwargs):
        """Cancel task with pending incoming transaction both incoming and outgoing [async call]  # noqa: E501

        A user may select to decline an incoming transaction. The related task will change its result to failure both on senders and the receivers side. This endpoint can also be used to cancel an outgoing pending transaction that is awaiting user interaction from the receiver  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_cancel_task_post_with_http_info(task_action_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param TaskActionRequest task_action_request: (required)
        :return: AsyncTaskCreatedResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['task_action_request']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')
        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s' to method node_cancel_task_post"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if 'task_action_request' not in local_var_params or local_var_params[
            'task_action_request'] is None:
            raise ValueError(
                'Missing the required parameter `task_action_request` when calling `node_cancel_task_post`'
                )
        collection_formats = {}
        path_params = {}
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        if 'task_action_request' in local_var_params:
            body_params = local_var_params['task_action_request']
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        header_params['Content-Type'
            ] = self.api_client.select_header_content_type(['application/json']
            )
        auth_settings = ['ApiKeyAuth']
        return self.api_client.call_api('/node/cancel_task', 'POST',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'AsyncTaskCreatedResponse', auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def node_delete_wallet_post(self, delete_wallet_request, **kwargs):
        """Delete a Wallet [async call]  # noqa: E501

        Deletes a Wallet from the Node; All private information about the Wallet will be deleted including transactional history, balances, and keys; If the secret key of the Wallet are not stored elsewhere then all Assets held in the Wallet will be forever lost! If the secret key of the Wallet is stored elsewhere, then all held Assets and the entire transactional history of the Wallet can be restored from the Blockchain at any time by importing the Wallet into a Node.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_delete_wallet_post(delete_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteWalletRequest delete_wallet_request: (required)
        :return: AsyncTaskCreatedResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_delete_wallet_post_with_http_info(
                delete_wallet_request, **kwargs)
        else:
            data = self.node_delete_wallet_post_with_http_info(
                delete_wallet_request, **kwargs)
            return data

    def node_delete_wallet_post_with_http_info(self, delete_wallet_request,
        **kwargs):
        """Delete a Wallet [async call]  # noqa: E501

        Deletes a Wallet from the Node; All private information about the Wallet will be deleted including transactional history, balances, and keys; If the secret key of the Wallet are not stored elsewhere then all Assets held in the Wallet will be forever lost! If the secret key of the Wallet is stored elsewhere, then all held Assets and the entire transactional history of the Wallet can be restored from the Blockchain at any time by importing the Wallet into a Node.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_delete_wallet_post_with_http_info(delete_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteWalletRequest delete_wallet_request: (required)
        :return: AsyncTaskCreatedResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['delete_wallet_request']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')
        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s' to method node_delete_wallet_post"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if 'delete_wallet_request' not in local_var_params or local_var_params[
            'delete_wallet_request'] is None:
            raise ValueError(
                'Missing the required parameter `delete_wallet_request` when calling `node_delete_wallet_post`'
                )
        collection_formats = {}
        path_params = {}
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        if 'delete_wallet_request' in local_var_params:
            body_params = local_var_params['delete_wallet_request']
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        header_params['Content-Type'
            ] = self.api_client.select_header_content_type(['application/json']
            )
        auth_settings = ['ApiKeyAuth']
        return self.api_client.call_api('/node/delete_wallet', 'POST',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'AsyncTaskCreatedResponse', auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def node_export_auditor_access_wallet_post(self,
        export_auditor_access_wallet_request, **kwargs):
        """Export viewing credentials for a Wallet  # noqa: E501

        Export a viewing key that allows viewing all transactions to and from a wallet, including past transactions. The viewing key is encrypted for a specific Address, and can only be recovered by someone in possession of either a secret key or a viewing key for the Wallet that Address belongs to. The viewing key does enable making any transactions (including rule changes, issuance, and transfers) on behalf of the exported Wallet.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_export_auditor_access_wallet_post(export_auditor_access_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ExportAuditorAccessWalletRequest export_auditor_access_wallet_request: (required)
        :return: ExportAuditorAccessWalletResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_export_auditor_access_wallet_post_with_http_info(
                export_auditor_access_wallet_request, **kwargs)
        else:
            data = self.node_export_auditor_access_wallet_post_with_http_info(
                export_auditor_access_wallet_request, **kwargs)
            return data

    def node_export_auditor_access_wallet_post_with_http_info(self,
        export_auditor_access_wallet_request, **kwargs):
        """Export viewing credentials for a Wallet  # noqa: E501

        Export a viewing key that allows viewing all transactions to and from a wallet, including past transactions. The viewing key is encrypted for a specific Address, and can only be recovered by someone in possession of either a secret key or a viewing key for the Wallet that Address belongs to. The viewing key does enable making any transactions (including rule changes, issuance, and transfers) on behalf of the exported Wallet.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_export_auditor_access_wallet_post_with_http_info(export_auditor_access_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ExportAuditorAccessWalletRequest export_auditor_access_wallet_request: (required)
        :return: ExportAuditorAccessWalletResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['export_auditor_access_wallet_request']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')
        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s' to method node_export_auditor_access_wallet_post"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if ('export_auditor_access_wallet_request' not in local_var_params or
            local_var_params['export_auditor_access_wallet_request'] is None):
            raise ValueError(
                'Missing the required parameter `export_auditor_access_wallet_request` when calling `node_export_auditor_access_wallet_post`'
                )
        collection_formats = {}
        path_params = {}
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        if 'export_auditor_access_wallet_request' in local_var_params:
            body_params = local_var_params[
                'export_auditor_access_wallet_request']
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        header_params['Content-Type'
            ] = self.api_client.select_header_content_type(['application/json']
            )
        auth_settings = ['ApiKeyAuth']
        return self.api_client.call_api('/node/export_auditor_access_wallet',
            'POST', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='ExportAuditorAccessWalletResponse',
            auth_settings=auth_settings, async_req=local_var_params.get(
            'async_req'), _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def node_export_wallet_post(self, export_wallet_request, **kwargs):
        """Export wallet secret key  # noqa: E501

        Export an encrypted form of the Wallet's secret key; The authorization password under which the secret key is encrypted is the same one under which it was originally created or imported; Knowledge of the secret key and the authorization password is required to import the Wallet into a Node in the future.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_export_wallet_post(export_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ExportWalletRequest export_wallet_request: (required)
        :return: ExportWalletResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_export_wallet_post_with_http_info(
                export_wallet_request, **kwargs)
        else:
            data = self.node_export_wallet_post_with_http_info(
                export_wallet_request, **kwargs)
            return data

    def node_export_wallet_post_with_http_info(self, export_wallet_request,
        **kwargs):
        """Export wallet secret key  # noqa: E501

        Export an encrypted form of the Wallet's secret key; The authorization password under which the secret key is encrypted is the same one under which it was originally created or imported; Knowledge of the secret key and the authorization password is required to import the Wallet into a Node in the future.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_export_wallet_post_with_http_info(export_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ExportWalletRequest export_wallet_request: (required)
        :return: ExportWalletResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['export_wallet_request']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')
        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s' to method node_export_wallet_post"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if 'export_wallet_request' not in local_var_params or local_var_params[
            'export_wallet_request'] is None:
            raise ValueError(
                'Missing the required parameter `export_wallet_request` when calling `node_export_wallet_post`'
                )
        collection_formats = {}
        path_params = {}
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        if 'export_wallet_request' in local_var_params:
            body_params = local_var_params['export_wallet_request']
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        header_params['Content-Type'
            ] = self.api_client.select_header_content_type(['application/json']
            )
        auth_settings = ['ApiKeyAuth']
        return self.api_client.call_api('/node/export_wallet', 'POST',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'ExportWalletResponse', auth_settings=auth_settings, async_req=
            local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def node_generate_wallet_post(self, generate_wallet_request, **kwargs):
        """Generate a new Wallet  # noqa: E501

        Randomly generate a new Wallet under a specified ID; This only affects the Node and in particular nothing about this action is broadcast to the Blockchain; The Wallet ID is required to be unique within the Node, but can otherwise be user-defined.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_generate_wallet_post(generate_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GenerateWalletRequest generate_wallet_request: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_generate_wallet_post_with_http_info(
                generate_wallet_request, **kwargs)
        else:
            data = self.node_generate_wallet_post_with_http_info(
                generate_wallet_request, **kwargs)
            return data

    def node_generate_wallet_post_with_http_info(self,
        generate_wallet_request, **kwargs):
        """Generate a new Wallet  # noqa: E501

        Randomly generate a new Wallet under a specified ID; This only affects the Node and in particular nothing about this action is broadcast to the Blockchain; The Wallet ID is required to be unique within the Node, but can otherwise be user-defined.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_generate_wallet_post_with_http_info(generate_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GenerateWalletRequest generate_wallet_request: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['generate_wallet_request']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')
        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s' to method node_generate_wallet_post"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if ('generate_wallet_request' not in local_var_params or 
            local_var_params['generate_wallet_request'] is None):
            raise ValueError(
                'Missing the required parameter `generate_wallet_request` when calling `node_generate_wallet_post`'
                )
        collection_formats = {}
        path_params = {}
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        if 'generate_wallet_request' in local_var_params:
            body_params = local_var_params['generate_wallet_request']
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        header_params['Content-Type'
            ] = self.api_client.select_header_content_type(['application/json']
            )
        auth_settings = ['ApiKeyAuth']
        return self.api_client.call_api('/node/generate_wallet', 'POST',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            None, auth_settings=auth_settings, async_req=local_var_params.
            get('async_req'), _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def node_get_all_wallets_post(self, **kwargs):
        """Get all wallet IDs  # noqa: E501

        Returns a list of the IDs of all Wallets currently stored on the Node. Both full-access and view-only Wallets are listed.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_get_all_wallets_post(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :return: GetAllWalletsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_get_all_wallets_post_with_http_info(**kwargs)
        else:
            data = self.node_get_all_wallets_post_with_http_info(**kwargs)
            return data

    def node_get_all_wallets_post_with_http_info(self, **kwargs):
        """Get all wallet IDs  # noqa: E501

        Returns a list of the IDs of all Wallets currently stored on the Node. Both full-access and view-only Wallets are listed.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_get_all_wallets_post_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :return: GetAllWalletsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = []
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')
        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s' to method node_get_all_wallets_post"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        collection_formats = {}
        path_params = {}
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['ApiKeyAuth']
        return self.api_client.call_api('/node/get_all_wallets', 'POST',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'GetAllWalletsResponse', auth_settings=auth_settings, async_req
            =local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def node_get_notifications_post(self, get_notifications_request, **kwargs):
        """Get notifications  # noqa: E501

        Notifications are the Node's way to report about recent activity and status changes. This endpoint allows polling for these changes and fetching the updates. The notifications can be filtered in multiple ways.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_get_notifications_post(get_notifications_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GetNotificationsRequest get_notifications_request: (required)
        :return: GetNotificationsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_get_notifications_post_with_http_info(
                get_notifications_request, **kwargs)
        else:
            data = self.node_get_notifications_post_with_http_info(
                get_notifications_request, **kwargs)
            return data

    def node_get_notifications_post_with_http_info(self,
        get_notifications_request, **kwargs):
        """Get notifications  # noqa: E501

        Notifications are the Node's way to report about recent activity and status changes. This endpoint allows polling for these changes and fetching the updates. The notifications can be filtered in multiple ways.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_get_notifications_post_with_http_info(get_notifications_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GetNotificationsRequest get_notifications_request: (required)
        :return: GetNotificationsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['get_notifications_request']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')
        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s' to method node_get_notifications_post"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if ('get_notifications_request' not in local_var_params or 
            local_var_params['get_notifications_request'] is None):
            raise ValueError(
                'Missing the required parameter `get_notifications_request` when calling `node_get_notifications_post`'
                )
        collection_formats = {}
        path_params = {}
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        if 'get_notifications_request' in local_var_params:
            body_params = local_var_params['get_notifications_request']
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        header_params['Content-Type'
            ] = self.api_client.select_header_content_type(['application/json']
            )
        auth_settings = ['ApiKeyAuth']
        return self.api_client.call_api('/node/get_notifications', 'POST',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'GetNotificationsResponse', auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def node_get_rules_post(self, **kwargs):
        """Get network governance Rules  # noqa: E501

        Returns a full list of all the Rules that govern admin and issuance rights within the network.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_get_rules_post(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :return: GetRulesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_get_rules_post_with_http_info(**kwargs)
        else:
            data = self.node_get_rules_post_with_http_info(**kwargs)
            return data

    def node_get_rules_post_with_http_info(self, **kwargs):
        """Get network governance Rules  # noqa: E501

        Returns a full list of all the Rules that govern admin and issuance rights within the network.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_get_rules_post_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :return: GetRulesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = []
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')
        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s' to method node_get_rules_post"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        collection_formats = {}
        path_params = {}
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['ApiKeyAuth']
        return self.api_client.call_api('/node/get_rules', 'POST',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'GetRulesResponse', auth_settings=auth_settings, async_req=
            local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def node_get_task_status_post(self, get_task_status_request, **kwargs):
        """Get a specific task (by ID)  # noqa: E501

        Returns the meta-data of a given Task and its current status. The particular, private details of the Task such as an Asset ID or amount in a Transfer are not returned.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_get_task_status_post(get_task_status_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GetTaskStatusRequest get_task_status_request: (required)
        :return: GetTaskStatusResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_get_task_status_post_with_http_info(
                get_task_status_request, **kwargs)
        else:
            data = self.node_get_task_status_post_with_http_info(
                get_task_status_request, **kwargs)
            return data

    def node_get_task_status_post_with_http_info(self,
        get_task_status_request, **kwargs):
        """Get a specific task (by ID)  # noqa: E501

        Returns the meta-data of a given Task and its current status. The particular, private details of the Task such as an Asset ID or amount in a Transfer are not returned.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_get_task_status_post_with_http_info(get_task_status_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GetTaskStatusRequest get_task_status_request: (required)
        :return: GetTaskStatusResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['get_task_status_request']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')
        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s' to method node_get_task_status_post"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if ('get_task_status_request' not in local_var_params or 
            local_var_params['get_task_status_request'] is None):
            raise ValueError(
                'Missing the required parameter `get_task_status_request` when calling `node_get_task_status_post`'
                )
        collection_formats = {}
        path_params = {}
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        if 'get_task_status_request' in local_var_params:
            body_params = local_var_params['get_task_status_request']
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        header_params['Content-Type'
            ] = self.api_client.select_header_content_type(['application/json']
            )
        auth_settings = ['ApiKeyAuth']
        return self.api_client.call_api('/node/get_task_status', 'POST',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'GetTaskStatusResponse', auth_settings=auth_settings, async_req
            =local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def node_get_tasks_post(self, get_tasks_request, **kwargs):
        """Get a (potentially) filtered list of all Tasks  # noqa: E501

        Returns a list of all Tasks along with their meta-data and statuses. The particular, private details of the Task such as an Asset ID or amount in a Transfer are not returned. Tasks can be filtered using various parameters as specified in the request body.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_get_tasks_post(get_tasks_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GetTasksRequest get_tasks_request: (required)
        :return: GetTasksResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_get_tasks_post_with_http_info(get_tasks_request,
                **kwargs)
        else:
            data = self.node_get_tasks_post_with_http_info(get_tasks_request,
                **kwargs)
            return data

    def node_get_tasks_post_with_http_info(self, get_tasks_request, **kwargs):
        """Get a (potentially) filtered list of all Tasks  # noqa: E501

        Returns a list of all Tasks along with their meta-data and statuses. The particular, private details of the Task such as an Asset ID or amount in a Transfer are not returned. Tasks can be filtered using various parameters as specified in the request body.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_get_tasks_post_with_http_info(get_tasks_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GetTasksRequest get_tasks_request: (required)
        :return: GetTasksResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['get_tasks_request']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')
        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s' to method node_get_tasks_post"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if 'get_tasks_request' not in local_var_params or local_var_params[
            'get_tasks_request'] is None:
            raise ValueError(
                'Missing the required parameter `get_tasks_request` when calling `node_get_tasks_post`'
                )
        collection_formats = {}
        path_params = {}
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        if 'get_tasks_request' in local_var_params:
            body_params = local_var_params['get_tasks_request']
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        header_params['Content-Type'
            ] = self.api_client.select_header_content_type(['application/json']
            )
        auth_settings = ['ApiKeyAuth']
        return self.api_client.call_api('/node/get_tasks', 'POST',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'GetTasksResponse', auth_settings=auth_settings, async_req=
            local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def node_import_auditor_access_wallet_post(self,
        import_auditor_access_wallet_request, **kwargs):
        """Import viewing credentials for a Wallet [async call]  # noqa: E501

        Import a viewing key generated by the export_auditor_access_wallet endpoint. This will create a read-only wallet which can be queried with endpoints such as get_activity and get_balances, but cannot be used to perform transactions. The Wallet whose Address was used as the recipient for the exported viewing key must already be imported within the Node in order for this process to succeed.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_import_auditor_access_wallet_post(import_auditor_access_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ImportAuditorAccessWalletRequest import_auditor_access_wallet_request: (required)
        :return: AsyncTaskCreatedResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_import_auditor_access_wallet_post_with_http_info(
                import_auditor_access_wallet_request, **kwargs)
        else:
            data = self.node_import_auditor_access_wallet_post_with_http_info(
                import_auditor_access_wallet_request, **kwargs)
            return data

    def node_import_auditor_access_wallet_post_with_http_info(self,
        import_auditor_access_wallet_request, **kwargs):
        """Import viewing credentials for a Wallet [async call]  # noqa: E501

        Import a viewing key generated by the export_auditor_access_wallet endpoint. This will create a read-only wallet which can be queried with endpoints such as get_activity and get_balances, but cannot be used to perform transactions. The Wallet whose Address was used as the recipient for the exported viewing key must already be imported within the Node in order for this process to succeed.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_import_auditor_access_wallet_post_with_http_info(import_auditor_access_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ImportAuditorAccessWalletRequest import_auditor_access_wallet_request: (required)
        :return: AsyncTaskCreatedResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['import_auditor_access_wallet_request']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')
        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s' to method node_import_auditor_access_wallet_post"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if ('import_auditor_access_wallet_request' not in local_var_params or
            local_var_params['import_auditor_access_wallet_request'] is None):
            raise ValueError(
                'Missing the required parameter `import_auditor_access_wallet_request` when calling `node_import_auditor_access_wallet_post`'
                )
        collection_formats = {}
        path_params = {}
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        if 'import_auditor_access_wallet_request' in local_var_params:
            body_params = local_var_params[
                'import_auditor_access_wallet_request']
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        header_params['Content-Type'
            ] = self.api_client.select_header_content_type(['application/json']
            )
        auth_settings = ['ApiKeyAuth']
        return self.api_client.call_api('/node/import_auditor_access_wallet',
            'POST', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='AsyncTaskCreatedResponse', auth_settings=
            auth_settings, async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def node_import_wallet_post(self, import_wallet_request, **kwargs):
        """Import Wallet from a known secret key and authorization [async call]  # noqa: E501

        Import a Wallet into the Node under a specified ID; All the transactional history and outstanding balanced of the Wallet will be extracted from the Blockchain; The Wallet ID is required to be unique within the Node, but can otherwise be user-defined.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_import_wallet_post(import_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ImportWalletRequest import_wallet_request: (required)
        :return: AsyncTaskCreatedResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_import_wallet_post_with_http_info(
                import_wallet_request, **kwargs)
        else:
            data = self.node_import_wallet_post_with_http_info(
                import_wallet_request, **kwargs)
            return data

    def node_import_wallet_post_with_http_info(self, import_wallet_request,
        **kwargs):
        """Import Wallet from a known secret key and authorization [async call]  # noqa: E501

        Import a Wallet into the Node under a specified ID; All the transactional history and outstanding balanced of the Wallet will be extracted from the Blockchain; The Wallet ID is required to be unique within the Node, but can otherwise be user-defined.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_import_wallet_post_with_http_info(import_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ImportWalletRequest import_wallet_request: (required)
        :return: AsyncTaskCreatedResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['import_wallet_request']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')
        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s' to method node_import_wallet_post"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if 'import_wallet_request' not in local_var_params or local_var_params[
            'import_wallet_request'] is None:
            raise ValueError(
                'Missing the required parameter `import_wallet_request` when calling `node_import_wallet_post`'
                )
        collection_formats = {}
        path_params = {}
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        if 'import_wallet_request' in local_var_params:
            body_params = local_var_params['import_wallet_request']
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        header_params['Content-Type'
            ] = self.api_client.select_header_content_type(['application/json']
            )
        auth_settings = ['ApiKeyAuth']
        return self.api_client.call_api('/node/import_wallet', 'POST',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'AsyncTaskCreatedResponse', auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

# coding: utf-8

"""
    QEDIT - Asset Transfers

    This SDK provides a programmatic way for interacting with QEDIT's _Asset Transfer_ API. The specification definition file is publicly available [in this repository](https://github.com/QED-it/asset_transfers_dev_guide/).   # noqa: E501

    OpenAPI spec version: 1.7.2
    Contact: dev@qed-it.com
    Generated by: https://openapi-generator.tech
"""


from __future__ import absolute_import

import re  # noqa: F401

# python 2 and python 3 compatibility library
import six

from pyqedit.api_client import ApiClient


class NodeApi(object):
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None):
        if api_client is None:
            api_client = ApiClient()
        self.api_client = api_client

    def node_approve_task_post(self, task_action_request, **kwargs):  # noqa: E501
        """Approve task with pending incoming transaction [async call]  # noqa: E501

        Confirmation request tasks are confirmed using this point. After the user confirms the incoming transaction, it is asynchronously sent to the blockchain and its status can be queried like any other async task.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_approve_task_post(task_action_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param TaskActionRequest task_action_request: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_approve_task_post_with_http_info(task_action_request, **kwargs)  # noqa: E501
        else:
            (data) = self.node_approve_task_post_with_http_info(task_action_request, **kwargs)  # noqa: E501
            return data

    def node_approve_task_post_with_http_info(self, task_action_request, **kwargs):  # noqa: E501
        """Approve task with pending incoming transaction [async call]  # noqa: E501

        Confirmation request tasks are confirmed using this point. After the user confirms the incoming transaction, it is asynchronously sent to the blockchain and its status can be queried like any other async task.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_approve_task_post_with_http_info(task_action_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param TaskActionRequest task_action_request: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

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

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

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        # Authentication setting
        auth_settings = ['ApiKeyAuth']  # noqa: E501

        return self.api_client.call_api(
            '/node/approve_task', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def node_cancel_task_post(self, task_action_request, **kwargs):  # noqa: E501
        """Cancel task with pending incoming transaction both incoming and outgoing [async call]  # noqa: E501

        A user may select to decline an incoming transaction. The related task will change its result to failure both on senders and the receivers side. This endpoint can also be used to cancel an outgoing pending transaction that is awaiting user interaction from the receiver  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_cancel_task_post(task_action_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param TaskActionRequest task_action_request: (required)
        :return: AsyncTaskCreatedResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_cancel_task_post_with_http_info(task_action_request, **kwargs)  # noqa: E501
        else:
            (data) = self.node_cancel_task_post_with_http_info(task_action_request, **kwargs)  # noqa: E501
            return data

    def node_cancel_task_post_with_http_info(self, task_action_request, **kwargs):  # noqa: E501
        """Cancel task with pending incoming transaction both incoming and outgoing [async call]  # noqa: E501

        A user may select to decline an incoming transaction. The related task will change its result to failure both on senders and the receivers side. This endpoint can also be used to cancel an outgoing pending transaction that is awaiting user interaction from the receiver  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_cancel_task_post_with_http_info(task_action_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param TaskActionRequest task_action_request: (required)
        :return: AsyncTaskCreatedResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

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

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

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        # Authentication setting
        auth_settings = ['ApiKeyAuth']  # noqa: E501

        return self.api_client.call_api(
            '/node/cancel_task', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='AsyncTaskCreatedResponse',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def node_delete_wallet_post(self, delete_wallet_request, **kwargs):  # noqa: E501
        """Delete a Wallet [async call]  # noqa: E501

        Deletes a Wallet from the Node; All private information about the Wallet will be deleted including transactional history, balances, and keys; If the secret key of the Wallet are not stored elsewhere then all Assets held in the Wallet will be forever lost! If the secret key of the Wallet is stored elsewhere, then all held Assets and the entire transactional history of the Wallet can be restored from the Blockchain at any time by importing the Wallet into a Node.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_delete_wallet_post(delete_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteWalletRequest delete_wallet_request: (required)
        :return: AsyncTaskCreatedResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_delete_wallet_post_with_http_info(delete_wallet_request, **kwargs)  # noqa: E501
        else:
            (data) = self.node_delete_wallet_post_with_http_info(delete_wallet_request, **kwargs)  # noqa: E501
            return data

    def node_delete_wallet_post_with_http_info(self, delete_wallet_request, **kwargs):  # noqa: E501
        """Delete a Wallet [async call]  # noqa: E501

        Deletes a Wallet from the Node; All private information about the Wallet will be deleted including transactional history, balances, and keys; If the secret key of the Wallet are not stored elsewhere then all Assets held in the Wallet will be forever lost! If the secret key of the Wallet is stored elsewhere, then all held Assets and the entire transactional history of the Wallet can be restored from the Blockchain at any time by importing the Wallet into a Node.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_delete_wallet_post_with_http_info(delete_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteWalletRequest delete_wallet_request: (required)
        :return: AsyncTaskCreatedResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

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

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

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        # Authentication setting
        auth_settings = ['ApiKeyAuth']  # noqa: E501

        return self.api_client.call_api(
            '/node/delete_wallet', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='AsyncTaskCreatedResponse',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def node_export_auditor_access_wallet_post(self, export_auditor_access_wallet_request, **kwargs):  # noqa: E501
        """Export viewing credentials for a Wallet  # noqa: E501

        Export a viewing key that allows viewing all transactions to and from a wallet, including past transactions. The viewing key is encrypted for a specific Address, and can only be recovered by someone in possession of either a secret key or a viewing key for the Wallet that Address belongs to. The viewing key does enable making any transactions (including rule changes, issuance, and transfers) on behalf of the exported Wallet.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_export_auditor_access_wallet_post(export_auditor_access_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ExportAuditorAccessWalletRequest export_auditor_access_wallet_request: (required)
        :return: ExportAuditorAccessWalletResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_export_auditor_access_wallet_post_with_http_info(export_auditor_access_wallet_request, **kwargs)  # noqa: E501
        else:
            (data) = self.node_export_auditor_access_wallet_post_with_http_info(export_auditor_access_wallet_request, **kwargs)  # noqa: E501
            return data

    def node_export_auditor_access_wallet_post_with_http_info(self, export_auditor_access_wallet_request, **kwargs):  # noqa: E501
        """Export viewing credentials for a Wallet  # noqa: E501

        Export a viewing key that allows viewing all transactions to and from a wallet, including past transactions. The viewing key is encrypted for a specific Address, and can only be recovered by someone in possession of either a secret key or a viewing key for the Wallet that Address belongs to. The viewing key does enable making any transactions (including rule changes, issuance, and transfers) on behalf of the exported Wallet.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_export_auditor_access_wallet_post_with_http_info(export_auditor_access_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ExportAuditorAccessWalletRequest export_auditor_access_wallet_request: (required)
        :return: ExportAuditorAccessWalletResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

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

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

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        # Authentication setting
        auth_settings = ['ApiKeyAuth']  # noqa: E501

        return self.api_client.call_api(
            '/node/export_auditor_access_wallet', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ExportAuditorAccessWalletResponse',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def node_export_wallet_post(self, export_wallet_request, **kwargs):  # noqa: E501
        """Export wallet secret key  # noqa: E501

        Export an encrypted form of the Wallet's secret key; The authorization password under which the secret key is encrypted is the same one under which it was originally created or imported; Knowledge of the secret key and the authorization password is required to import the Wallet into a Node in the future.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_export_wallet_post(export_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ExportWalletRequest export_wallet_request: (required)
        :return: ExportWalletResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_export_wallet_post_with_http_info(export_wallet_request, **kwargs)  # noqa: E501
        else:
            (data) = self.node_export_wallet_post_with_http_info(export_wallet_request, **kwargs)  # noqa: E501
            return data

    def node_export_wallet_post_with_http_info(self, export_wallet_request, **kwargs):  # noqa: E501
        """Export wallet secret key  # noqa: E501

        Export an encrypted form of the Wallet's secret key; The authorization password under which the secret key is encrypted is the same one under which it was originally created or imported; Knowledge of the secret key and the authorization password is required to import the Wallet into a Node in the future.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_export_wallet_post_with_http_info(export_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ExportWalletRequest export_wallet_request: (required)
        :return: ExportWalletResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

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

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

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        # Authentication setting
        auth_settings = ['ApiKeyAuth']  # noqa: E501

        return self.api_client.call_api(
            '/node/export_wallet', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ExportWalletResponse',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def node_generate_wallet_post(self, generate_wallet_request, **kwargs):  # noqa: E501
        """Generate a new Wallet  # noqa: E501

        Randomly generate a new Wallet under a specified ID; This only affects the Node and in particular nothing about this action is broadcast to the Blockchain; The Wallet ID is required to be unique within the Node, but can otherwise be user-defined.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_generate_wallet_post(generate_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GenerateWalletRequest generate_wallet_request: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_generate_wallet_post_with_http_info(generate_wallet_request, **kwargs)  # noqa: E501
        else:
            (data) = self.node_generate_wallet_post_with_http_info(generate_wallet_request, **kwargs)  # noqa: E501
            return data

    def node_generate_wallet_post_with_http_info(self, generate_wallet_request, **kwargs):  # noqa: E501
        """Generate a new Wallet  # noqa: E501

        Randomly generate a new Wallet under a specified ID; This only affects the Node and in particular nothing about this action is broadcast to the Blockchain; The Wallet ID is required to be unique within the Node, but can otherwise be user-defined.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_generate_wallet_post_with_http_info(generate_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GenerateWalletRequest generate_wallet_request: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

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

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

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        # Authentication setting
        auth_settings = ['ApiKeyAuth']  # noqa: E501

        return self.api_client.call_api(
            '/node/generate_wallet', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def node_get_all_wallets_post(self, **kwargs):  # noqa: E501
        """Get all wallet IDs  # noqa: E501

        Returns a list of the IDs of all Wallets currently stored on the Node. Both full-access and view-only Wallets are listed.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_get_all_wallets_post(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :return: GetAllWalletsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_get_all_wallets_post_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.node_get_all_wallets_post_with_http_info(**kwargs)  # noqa: E501
            return data

    def node_get_all_wallets_post_with_http_info(self, **kwargs):  # noqa: E501
        """Get all wallet IDs  # noqa: E501

        Returns a list of the IDs of all Wallets currently stored on the Node. Both full-access and view-only Wallets are listed.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_get_all_wallets_post_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :return: GetAllWalletsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

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

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method node_get_all_wallets_post" % key
                )
            local_var_params[key] = val
        del local_var_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'])  # noqa: E501

        # Authentication setting
        auth_settings = ['ApiKeyAuth']  # noqa: E501

        return self.api_client.call_api(
            '/node/get_all_wallets', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='GetAllWalletsResponse',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def node_get_notifications_post(self, get_notifications_request, **kwargs):  # noqa: E501
        """Get notifications  # noqa: E501

        Notifications are the Node's way to report about recent activity and status changes. This endpoint allows polling for these changes and fetching the updates. The notifications can be filtered in multiple ways.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_get_notifications_post(get_notifications_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GetNotificationsRequest get_notifications_request: (required)
        :return: GetNotificationsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_get_notifications_post_with_http_info(get_notifications_request, **kwargs)  # noqa: E501
        else:
            (data) = self.node_get_notifications_post_with_http_info(get_notifications_request, **kwargs)  # noqa: E501
            return data

    def node_get_notifications_post_with_http_info(self, get_notifications_request, **kwargs):  # noqa: E501
        """Get notifications  # noqa: E501

        Notifications are the Node's way to report about recent activity and status changes. This endpoint allows polling for these changes and fetching the updates. The notifications can be filtered in multiple ways.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_get_notifications_post_with_http_info(get_notifications_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GetNotificationsRequest get_notifications_request: (required)
        :return: GetNotificationsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

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

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

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        # Authentication setting
        auth_settings = ['ApiKeyAuth']  # noqa: E501

        return self.api_client.call_api(
            '/node/get_notifications', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='GetNotificationsResponse',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def node_get_rules_post(self, **kwargs):  # noqa: E501
        """Get network governance Rules  # noqa: E501

        Returns a full list of all the Rules that govern admin and issuance rights within the network.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_get_rules_post(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :return: GetRulesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_get_rules_post_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.node_get_rules_post_with_http_info(**kwargs)  # noqa: E501
            return data

    def node_get_rules_post_with_http_info(self, **kwargs):  # noqa: E501
        """Get network governance Rules  # noqa: E501

        Returns a full list of all the Rules that govern admin and issuance rights within the network.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_get_rules_post_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :return: GetRulesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

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

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method node_get_rules_post" % key
                )
            local_var_params[key] = val
        del local_var_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'])  # noqa: E501

        # Authentication setting
        auth_settings = ['ApiKeyAuth']  # noqa: E501

        return self.api_client.call_api(
            '/node/get_rules', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='GetRulesResponse',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def node_get_task_status_post(self, get_task_status_request, **kwargs):  # noqa: E501
        """Get a specific task (by ID)  # noqa: E501

        Returns the meta-data of a given Task and its current status. The particular, private details of the Task such as an Asset ID or amount in a Transfer are not returned.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_get_task_status_post(get_task_status_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GetTaskStatusRequest get_task_status_request: (required)
        :return: GetTaskStatusResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_get_task_status_post_with_http_info(get_task_status_request, **kwargs)  # noqa: E501
        else:
            (data) = self.node_get_task_status_post_with_http_info(get_task_status_request, **kwargs)  # noqa: E501
            return data

    def node_get_task_status_post_with_http_info(self, get_task_status_request, **kwargs):  # noqa: E501
        """Get a specific task (by ID)  # noqa: E501

        Returns the meta-data of a given Task and its current status. The particular, private details of the Task such as an Asset ID or amount in a Transfer are not returned.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_get_task_status_post_with_http_info(get_task_status_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GetTaskStatusRequest get_task_status_request: (required)
        :return: GetTaskStatusResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

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

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

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        # Authentication setting
        auth_settings = ['ApiKeyAuth']  # noqa: E501

        return self.api_client.call_api(
            '/node/get_task_status', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='GetTaskStatusResponse',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def node_get_tasks_post(self, get_tasks_request, **kwargs):  # noqa: E501
        """Get a (potentially) filtered list of all Tasks  # noqa: E501

        Returns a list of all Tasks along with their meta-data and statuses. The particular, private details of the Task such as an Asset ID or amount in a Transfer are not returned. Tasks can be filtered using various parameters as specified in the request body.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_get_tasks_post(get_tasks_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GetTasksRequest get_tasks_request: (required)
        :return: GetTasksResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_get_tasks_post_with_http_info(get_tasks_request, **kwargs)  # noqa: E501
        else:
            (data) = self.node_get_tasks_post_with_http_info(get_tasks_request, **kwargs)  # noqa: E501
            return data

    def node_get_tasks_post_with_http_info(self, get_tasks_request, **kwargs):  # noqa: E501
        """Get a (potentially) filtered list of all Tasks  # noqa: E501

        Returns a list of all Tasks along with their meta-data and statuses. The particular, private details of the Task such as an Asset ID or amount in a Transfer are not returned. Tasks can be filtered using various parameters as specified in the request body.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_get_tasks_post_with_http_info(get_tasks_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GetTasksRequest get_tasks_request: (required)
        :return: GetTasksResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

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

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

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        # Authentication setting
        auth_settings = ['ApiKeyAuth']  # noqa: E501

        return self.api_client.call_api(
            '/node/get_tasks', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='GetTasksResponse',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def node_import_auditor_access_wallet_post(self, import_auditor_access_wallet_request, **kwargs):  # noqa: E501
        """Import viewing credentials for a Wallet [async call]  # noqa: E501

        Import a viewing key generated by the export_auditor_access_wallet endpoint. This will create a read-only wallet which can be queried with endpoints such as get_activity and get_balances, but cannot be used to perform transactions. The Wallet whose Address was used as the recipient for the exported viewing key must already be imported within the Node in order for this process to succeed.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_import_auditor_access_wallet_post(import_auditor_access_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ImportAuditorAccessWalletRequest import_auditor_access_wallet_request: (required)
        :return: AsyncTaskCreatedResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_import_auditor_access_wallet_post_with_http_info(import_auditor_access_wallet_request, **kwargs)  # noqa: E501
        else:
            (data) = self.node_import_auditor_access_wallet_post_with_http_info(import_auditor_access_wallet_request, **kwargs)  # noqa: E501
            return data

    def node_import_auditor_access_wallet_post_with_http_info(self, import_auditor_access_wallet_request, **kwargs):  # noqa: E501
        """Import viewing credentials for a Wallet [async call]  # noqa: E501

        Import a viewing key generated by the export_auditor_access_wallet endpoint. This will create a read-only wallet which can be queried with endpoints such as get_activity and get_balances, but cannot be used to perform transactions. The Wallet whose Address was used as the recipient for the exported viewing key must already be imported within the Node in order for this process to succeed.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_import_auditor_access_wallet_post_with_http_info(import_auditor_access_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ImportAuditorAccessWalletRequest import_auditor_access_wallet_request: (required)
        :return: AsyncTaskCreatedResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

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

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

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        # Authentication setting
        auth_settings = ['ApiKeyAuth']  # noqa: E501

        return self.api_client.call_api(
            '/node/import_auditor_access_wallet', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='AsyncTaskCreatedResponse',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def node_import_wallet_post(self, import_wallet_request, **kwargs):  # noqa: E501
        """Import Wallet from a known secret key and authorization [async call]  # noqa: E501

        Import a Wallet into the Node under a specified ID; All the transactional history and outstanding balanced of the Wallet will be extracted from the Blockchain; The Wallet ID is required to be unique within the Node, but can otherwise be user-defined.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_import_wallet_post(import_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ImportWalletRequest import_wallet_request: (required)
        :return: AsyncTaskCreatedResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.node_import_wallet_post_with_http_info(import_wallet_request, **kwargs)  # noqa: E501
        else:
            (data) = self.node_import_wallet_post_with_http_info(import_wallet_request, **kwargs)  # noqa: E501
            return data

    def node_import_wallet_post_with_http_info(self, import_wallet_request, **kwargs):  # noqa: E501
        """Import Wallet from a known secret key and authorization [async call]  # noqa: E501

        Import a Wallet into the Node under a specified ID; All the transactional history and outstanding balanced of the Wallet will be extracted from the Blockchain; The Wallet ID is required to be unique within the Node, but can otherwise be user-defined.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.node_import_wallet_post_with_http_info(import_wallet_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ImportWalletRequest import_wallet_request: (required)
        :return: AsyncTaskCreatedResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

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

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

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        # Authentication setting
        auth_settings = ['ApiKeyAuth']  # noqa: E501

        return self.api_client.call_api(
            '/node/import_wallet', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='AsyncTaskCreatedResponse',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)
