# coding: utf-8

"""
    Coinsecure Api Documentation

    To generate an API key, please visit <a href='https://coinsecure.in/api' target='_new' class='homeapi'>https://coinsecure.in/api</a>.<br>Guidelines for use can be accessed at <a href='https://api.coinsecure.in/v1/guidelines'>https://api.coinsecure.in/v1/guidelines</a>.<br>Programming Language Libraries for use can be accessed at <a href='https://api.coinsecure.in/v1/code-libraries'>https://api.coinsecure.in/v1/code-libraries</a>.

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

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at

        http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
"""

from __future__ import absolute_import

import sys
import os
import re

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

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


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

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

    def v1userexchangebankcoinaddresses(self, authorization, **kwargs):
        """
        Exchange Coin Addresses
        Gets a List of Users Exchange Bitcoin Deposit Addresses.

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

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str authorization: API object to be added (required)
        :param str accept: JSON, XML or CSV can be returned (Optional)
        :return: TradeAddressDataResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.v1userexchangebankcoinaddresses_with_http_info(authorization, **kwargs)
        else:
            (data) = self.v1userexchangebankcoinaddresses_with_http_info(authorization, **kwargs)
            return data

    def v1userexchangebankcoinaddresses_with_http_info(self, authorization, **kwargs):
        """
        Exchange Coin Addresses
        Gets a List of Users Exchange Bitcoin Deposit Addresses.

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

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str authorization: API object to be added (required)
        :param str accept: JSON, XML or CSV can be returned (Optional)
        :return: TradeAddressDataResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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


        collection_formats = {}

        resource_path = '/v1/user/exchange/bank/coin/addresses'.replace('{format}', 'json')
        path_params = {}

        query_params = {}

        header_params = {}
        if 'authorization' in params:
            header_params['Authorization'] = params['authorization']
        if 'accept' in params:
            header_params['accept'] = params['accept']

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json', 'application/xml', 'application/csv'])
        if not header_params['Accept']:
            del header_params['Accept']

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

        # Authentication setting
        auth_settings = []

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

    def v1userexchangebankcoinbalanceavailable(self, authorization, **kwargs):
        """
        Available Exchange Coin Balance
        Returns balance which is in Available for Trades. The response is in satoshis.

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

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str authorization: API object to be added (required)
        :param str accept: JSON, XML or CSV can be returned (Optional)
        :return: VolDataResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.v1userexchangebankcoinbalanceavailable_with_http_info(authorization, **kwargs)
        else:
            (data) = self.v1userexchangebankcoinbalanceavailable_with_http_info(authorization, **kwargs)
            return data

    def v1userexchangebankcoinbalanceavailable_with_http_info(self, authorization, **kwargs):
        """
        Available Exchange Coin Balance
        Returns balance which is in Available for Trades. The response is in satoshis.

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

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str authorization: API object to be added (required)
        :param str accept: JSON, XML or CSV can be returned (Optional)
        :return: VolDataResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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


        collection_formats = {}

        resource_path = '/v1/user/exchange/bank/coin/balance/total'.replace('{format}', 'json')
        path_params = {}

        query_params = {}

        header_params = {}
        if 'authorization' in params:
            header_params['Authorization'] = params['authorization']
        if 'accept' in params:
            header_params['accept'] = params['accept']

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json', 'application/xml', 'application/csv'])
        if not header_params['Accept']:
            del header_params['Accept']

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

        # Authentication setting
        auth_settings = []

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

    def v1userexchangebankcoinbalancepending(self, authorization, **kwargs):
        """
        In Trade Coin Balance
        Returns in-trade or pending coin balance in satoshi.

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

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str authorization: API object to be added (required)
        :param str accept: JSON, XML or CSV can be returned (Optional)
        :return: VolDataResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.v1userexchangebankcoinbalancepending_with_http_info(authorization, **kwargs)
        else:
            (data) = self.v1userexchangebankcoinbalancepending_with_http_info(authorization, **kwargs)
            return data

    def v1userexchangebankcoinbalancepending_with_http_info(self, authorization, **kwargs):
        """
        In Trade Coin Balance
        Returns in-trade or pending coin balance in satoshi.

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

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str authorization: API object to be added (required)
        :param str accept: JSON, XML or CSV can be returned (Optional)
        :return: VolDataResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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


        collection_formats = {}

        resource_path = '/v1/user/exchange/bank/coin/balance/pending'.replace('{format}', 'json')
        path_params = {}

        query_params = {}

        header_params = {}
        if 'authorization' in params:
            header_params['Authorization'] = params['authorization']
        if 'accept' in params:
            header_params['accept'] = params['accept']

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json', 'application/xml', 'application/csv'])
        if not header_params['Accept']:
            del header_params['Accept']

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

        # Authentication setting
        auth_settings = []

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

    def v1userexchangebankcoinbalancetotal(self, authorization, **kwargs):
        """
        Total Exchange Coin Balance
        Returns users total coin balance in satoshis. Pending + Available

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

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str authorization: API object to be added (required)
        :param str accept: JSON, XML or CSV can be returned (Optional)
        :return: VolDataResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.v1userexchangebankcoinbalancetotal_with_http_info(authorization, **kwargs)
        else:
            (data) = self.v1userexchangebankcoinbalancetotal_with_http_info(authorization, **kwargs)
            return data

    def v1userexchangebankcoinbalancetotal_with_http_info(self, authorization, **kwargs):
        """
        Total Exchange Coin Balance
        Returns users total coin balance in satoshis. Pending + Available

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

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str authorization: API object to be added (required)
        :param str accept: JSON, XML or CSV can be returned (Optional)
        :return: VolDataResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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


        collection_formats = {}

        resource_path = '/v1/user/exchange/bank/coin/balance/available'.replace('{format}', 'json')
        path_params = {}

        query_params = {}

        header_params = {}
        if 'authorization' in params:
            header_params['Authorization'] = params['authorization']
        if 'accept' in params:
            header_params['accept'] = params['accept']

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json', 'application/xml', 'application/csv'])
        if not header_params['Accept']:
            del header_params['Accept']

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

        # Authentication setting
        auth_settings = []

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

    def v1userexchangebankcoindepositcancelled(self, authorization, **kwargs):
        """
        Cancelled Exchange Coin Deposits
        Gets a List of Cancelled Exchange Coin Deposits. The value and fees are in paisa.

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

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str authorization: API object to be added (required)
        :param int _from: From date in Epoch, defaults to 0 if invalid input or greater than current time. (Optional)
        :param int to: To Date in Epoch, defaults to current time if invalid input or greater than current time. (Optional)
        :param int max: Max defaults to 10 if invalid input and defaults to 100 if greater than 100. (Optional)
        :param int offset: Offset defaults to 0 if input is invalid. (Optional)
        :param str accept: JSON, XML or CSV can be returned (Optional)
        :return: CoinDepDataResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.v1userexchangebankcoindepositcancelled_with_http_info(authorization, **kwargs)
        else:
            (data) = self.v1userexchangebankcoindepositcancelled_with_http_info(authorization, **kwargs)
            return data

    def v1userexchangebankcoindepositcancelled_with_http_info(self, authorization, **kwargs):
        """
        Cancelled Exchange Coin Deposits
        Gets a List of Cancelled Exchange Coin Deposits. The value and fees are in paisa.

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

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str authorization: API object to be added (required)
        :param int _from: From date in Epoch, defaults to 0 if invalid input or greater than current time. (Optional)
        :param int to: To Date in Epoch, defaults to current time if invalid input or greater than current time. (Optional)
        :param int max: Max defaults to 10 if invalid input and defaults to 100 if greater than 100. (Optional)
        :param int offset: Offset defaults to 0 if input is invalid. (Optional)
        :param str accept: JSON, XML or CSV can be returned (Optional)
        :return: CoinDepDataResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['authorization', '_from', 'to', 'max', 'offset', 'accept']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

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


        collection_formats = {}

        resource_path = '/v1/user/exchange/bank/coin/deposit/cancelled'.replace('{format}', 'json')
        path_params = {}

        query_params = {}
        if '_from' in params:
            query_params['from'] = params['_from']
        if 'to' in params:
            query_params['to'] = params['to']
        if 'max' in params:
            query_params['max'] = params['max']
        if 'offset' in params:
            query_params['offset'] = params['offset']

        header_params = {}
        if 'authorization' in params:
            header_params['Authorization'] = params['authorization']
        if 'accept' in params:
            header_params['accept'] = params['accept']

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json', 'application/xml', 'application/csv'])
        if not header_params['Accept']:
            del header_params['Accept']

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

        # Authentication setting
        auth_settings = []

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

    def v1userexchangebankcoindepositunverified(self, authorization, **kwargs):
        """
        Unverified Exchange Coin Deposits
        Gets a List of Unverified Exchange Coin Deposits. The value and fees are in paisa.

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

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str authorization: API object to be added (required)
        :param int _from: From date in Epoch, defaults to 0 if invalid input or greater than current time. (Optional)
        :param int to: To Date in Epoch, defaults to current time if invalid input or greater than current time. (Optional)
        :param int max: Max defaults to 10 if invalid input and defaults to 100 if greater than 100. (Optional)
        :param int offset: Offset defaults to 0 if input is invalid. (Optional)
        :param str accept: JSON, XML or CSV can be returned (Optional)
        :return: CoinDepDataResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.v1userexchangebankcoindepositunverified_with_http_info(authorization, **kwargs)
        else:
            (data) = self.v1userexchangebankcoindepositunverified_with_http_info(authorization, **kwargs)
            return data

    def v1userexchangebankcoindepositunverified_with_http_info(self, authorization, **kwargs):
        """
        Unverified Exchange Coin Deposits
        Gets a List of Unverified Exchange Coin Deposits. The value and fees are in paisa.

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

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str authorization: API object to be added (required)
        :param int _from: From date in Epoch, defaults to 0 if invalid input or greater than current time. (Optional)
        :param int to: To Date in Epoch, defaults to current time if invalid input or greater than current time. (Optional)
        :param int max: Max defaults to 10 if invalid input and defaults to 100 if greater than 100. (Optional)
        :param int offset: Offset defaults to 0 if input is invalid. (Optional)
        :param str accept: JSON, XML or CSV can be returned (Optional)
        :return: CoinDepDataResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['authorization', '_from', 'to', 'max', 'offset', 'accept']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

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


        collection_formats = {}

        resource_path = '/v1/user/exchange/bank/coin/deposit/unverified'.replace('{format}', 'json')
        path_params = {}

        query_params = {}
        if '_from' in params:
            query_params['from'] = params['_from']
        if 'to' in params:
            query_params['to'] = params['to']
        if 'max' in params:
            query_params['max'] = params['max']
        if 'offset' in params:
            query_params['offset'] = params['offset']

        header_params = {}
        if 'authorization' in params:
            header_params['Authorization'] = params['authorization']
        if 'accept' in params:
            header_params['accept'] = params['accept']

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json', 'application/xml', 'application/csv'])
        if not header_params['Accept']:
            del header_params['Accept']

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

        # Authentication setting
        auth_settings = []

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

    def v1userexchangebankcoindepositverified(self, authorization, **kwargs):
        """
        Verified Exchange Coin Deposits
        Gets a List of Verified Exchange Coin Deposits. The value and fees are in paisa.

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

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str authorization: API object to be added (required)
        :param int _from: From date in Epoch, defaults to 0 if invalid input or greater than current time. (Optional)
        :param int to: To Date in Epoch, defaults to current time if invalid input or greater than current time. (Optional)
        :param int max: Max defaults to 10 if invalid input and defaults to 100 if greater than 100. (Optional)
        :param int offset: Offset defaults to 0 if input is invalid. (Optional)
        :param str accept: JSON, XML or CSV can be returned (Optional)
        :return: CoinDepDataResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.v1userexchangebankcoindepositverified_with_http_info(authorization, **kwargs)
        else:
            (data) = self.v1userexchangebankcoindepositverified_with_http_info(authorization, **kwargs)
            return data

    def v1userexchangebankcoindepositverified_with_http_info(self, authorization, **kwargs):
        """
        Verified Exchange Coin Deposits
        Gets a List of Verified Exchange Coin Deposits. The value and fees are in paisa.

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

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str authorization: API object to be added (required)
        :param int _from: From date in Epoch, defaults to 0 if invalid input or greater than current time. (Optional)
        :param int to: To Date in Epoch, defaults to current time if invalid input or greater than current time. (Optional)
        :param int max: Max defaults to 10 if invalid input and defaults to 100 if greater than 100. (Optional)
        :param int offset: Offset defaults to 0 if input is invalid. (Optional)
        :param str accept: JSON, XML or CSV can be returned (Optional)
        :return: CoinDepDataResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['authorization', '_from', 'to', 'max', 'offset', 'accept']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

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


        collection_formats = {}

        resource_path = '/v1/user/exchange/bank/coin/deposit/verified'.replace('{format}', 'json')
        path_params = {}

        query_params = {}
        if '_from' in params:
            query_params['from'] = params['_from']
        if 'to' in params:
            query_params['to'] = params['to']
        if 'max' in params:
            query_params['max'] = params['max']
        if 'offset' in params:
            query_params['offset'] = params['offset']

        header_params = {}
        if 'authorization' in params:
            header_params['Authorization'] = params['authorization']
        if 'accept' in params:
            header_params['accept'] = params['accept']

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json', 'application/xml', 'application/csv'])
        if not header_params['Accept']:
            del header_params['Accept']

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

        # Authentication setting
        auth_settings = []

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

    def v1userexchangebankcoinwithdrawcancelled(self, authorization, **kwargs):
        """
        Cancelled Exchange Coin Withdrawals
        Gets a List of Cancelled Coin Withdrawals. The value and fees are in satoshis.

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

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str authorization: API object to be added (required)
        :param int _from: From date in Epoch, defaults to 0 if invalid input or greater than current time. (Optional)
        :param int to: To Date in Epoch, defaults to current time if invalid input or greater than current time. (Optional)
        :param int max: Max defaults to 10 if invalid input and defaults to 100 if greater than 100. (Optional)
        :param int offset: Offset defaults to 0 if input is invalid. (Optional)
        :param str accept: JSON, XML or CSV can be returned (Optional)
        :return: TradeCoinWithdrawDataResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.v1userexchangebankcoinwithdrawcancelled_with_http_info(authorization, **kwargs)
        else:
            (data) = self.v1userexchangebankcoinwithdrawcancelled_with_http_info(authorization, **kwargs)
            return data

    def v1userexchangebankcoinwithdrawcancelled_with_http_info(self, authorization, **kwargs):
        """
        Cancelled Exchange Coin Withdrawals
        Gets a List of Cancelled Coin Withdrawals. The value and fees are in satoshis.

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

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str authorization: API object to be added (required)
        :param int _from: From date in Epoch, defaults to 0 if invalid input or greater than current time. (Optional)
        :param int to: To Date in Epoch, defaults to current time if invalid input or greater than current time. (Optional)
        :param int max: Max defaults to 10 if invalid input and defaults to 100 if greater than 100. (Optional)
        :param int offset: Offset defaults to 0 if input is invalid. (Optional)
        :param str accept: JSON, XML or CSV can be returned (Optional)
        :return: TradeCoinWithdrawDataResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['authorization', '_from', 'to', 'max', 'offset', 'accept']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

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


        collection_formats = {}

        resource_path = '/v1/user/exchange/bank/coin/withdraw/cancelled'.replace('{format}', 'json')
        path_params = {}

        query_params = {}
        if '_from' in params:
            query_params['from'] = params['_from']
        if 'to' in params:
            query_params['to'] = params['to']
        if 'max' in params:
            query_params['max'] = params['max']
        if 'offset' in params:
            query_params['offset'] = params['offset']

        header_params = {}
        if 'authorization' in params:
            header_params['Authorization'] = params['authorization']
        if 'accept' in params:
            header_params['accept'] = params['accept']

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json', 'application/xml', 'application/csv'])
        if not header_params['Accept']:
            del header_params['Accept']

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

        # Authentication setting
        auth_settings = []

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

    def v1userexchangebankcoinwithdrawcompleted(self, authorization, **kwargs):
        """
        Completed Exchange Coin Withdrawals
        Gets a List of Completed Coin Withdrawals. The value and fees are in satoshis.

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

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str authorization: API object to be added (required)
        :param int _from: From date in Epoch, defaults to 0 if invalid input or greater than current time. (Optional)
        :param int to: To Date in Epoch, defaults to current time if invalid input or greater than current time. (Optional)
        :param int max: Max defaults to 10 if invalid input and defaults to 100 if greater than 100. (Optional)
        :param int offset: Offset defaults to 0 if input is invalid. (Optional)
        :param str accept: JSON, XML or CSV can be returned (Optional)
        :return: TradeCoinWithdrawDataResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.v1userexchangebankcoinwithdrawcompleted_with_http_info(authorization, **kwargs)
        else:
            (data) = self.v1userexchangebankcoinwithdrawcompleted_with_http_info(authorization, **kwargs)
            return data

    def v1userexchangebankcoinwithdrawcompleted_with_http_info(self, authorization, **kwargs):
        """
        Completed Exchange Coin Withdrawals
        Gets a List of Completed Coin Withdrawals. The value and fees are in satoshis.

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

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str authorization: API object to be added (required)
        :param int _from: From date in Epoch, defaults to 0 if invalid input or greater than current time. (Optional)
        :param int to: To Date in Epoch, defaults to current time if invalid input or greater than current time. (Optional)
        :param int max: Max defaults to 10 if invalid input and defaults to 100 if greater than 100. (Optional)
        :param int offset: Offset defaults to 0 if input is invalid. (Optional)
        :param str accept: JSON, XML or CSV can be returned (Optional)
        :return: TradeCoinWithdrawDataResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['authorization', '_from', 'to', 'max', 'offset', 'accept']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

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


        collection_formats = {}

        resource_path = '/v1/user/exchange/bank/coin/withdraw/completed'.replace('{format}', 'json')
        path_params = {}

        query_params = {}
        if '_from' in params:
            query_params['from'] = params['_from']
        if 'to' in params:
            query_params['to'] = params['to']
        if 'max' in params:
            query_params['max'] = params['max']
        if 'offset' in params:
            query_params['offset'] = params['offset']

        header_params = {}
        if 'authorization' in params:
            header_params['Authorization'] = params['authorization']
        if 'accept' in params:
            header_params['accept'] = params['accept']

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json', 'application/xml', 'application/csv'])
        if not header_params['Accept']:
            del header_params['Accept']

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

        # Authentication setting
        auth_settings = []

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

    def v1userexchangebankcoinwithdrawunverified(self, authorization, **kwargs):
        """
        Unverified Exchange Coin Withdrawals
        Gets a List of Unverified Exchange Coin Withdrawals. The value and fees are in satoshis.

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

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str authorization: API object to be added (required)
        :param int _from: From date in Epoch, defaults to 0 if invalid input or greater than current time. (Optional)
        :param int to: To Date in Epoch, defaults to current time if invalid input or greater than current time. (Optional)
        :param int max: Max defaults to 10 if invalid input and defaults to 100 if greater than 100. (Optional)
        :param int offset: Offset defaults to 0 if input is invalid. (Optional)
        :param str accept: JSON, XML or CSV can be returned (Optional)
        :return: TradeCoinWithdrawDataResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.v1userexchangebankcoinwithdrawunverified_with_http_info(authorization, **kwargs)
        else:
            (data) = self.v1userexchangebankcoinwithdrawunverified_with_http_info(authorization, **kwargs)
            return data

    def v1userexchangebankcoinwithdrawunverified_with_http_info(self, authorization, **kwargs):
        """
        Unverified Exchange Coin Withdrawals
        Gets a List of Unverified Exchange Coin Withdrawals. The value and fees are in satoshis.

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

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str authorization: API object to be added (required)
        :param int _from: From date in Epoch, defaults to 0 if invalid input or greater than current time. (Optional)
        :param int to: To Date in Epoch, defaults to current time if invalid input or greater than current time. (Optional)
        :param int max: Max defaults to 10 if invalid input and defaults to 100 if greater than 100. (Optional)
        :param int offset: Offset defaults to 0 if input is invalid. (Optional)
        :param str accept: JSON, XML or CSV can be returned (Optional)
        :return: TradeCoinWithdrawDataResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['authorization', '_from', 'to', 'max', 'offset', 'accept']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

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


        collection_formats = {}

        resource_path = '/v1/user/exchange/bank/coin/withdraw/unverified'.replace('{format}', 'json')
        path_params = {}

        query_params = {}
        if '_from' in params:
            query_params['from'] = params['_from']
        if 'to' in params:
            query_params['to'] = params['to']
        if 'max' in params:
            query_params['max'] = params['max']
        if 'offset' in params:
            query_params['offset'] = params['offset']

        header_params = {}
        if 'authorization' in params:
            header_params['Authorization'] = params['authorization']
        if 'accept' in params:
            header_params['accept'] = params['accept']

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json', 'application/xml', 'application/csv'])
        if not header_params['Accept']:
            del header_params['Accept']

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

        # Authentication setting
        auth_settings = []

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

    def v1userexchangebankcoinwithdrawverified(self, authorization, **kwargs):
        """
        Verified Exchange Coin Withdrawals
        Gets a List of Verified Exchange Coin Withdrawals. The value and fees are in satoshis.

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

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str authorization: API object to be added (required)
        :param int _from: From date in Epoch, defaults to 0 if invalid input or greater than current time. (Optional)
        :param int to: To Date in Epoch, defaults to current time if invalid input or greater than current time. (Optional)
        :param int max: Max defaults to 10 if invalid input and defaults to 100 if greater than 100. (Optional)
        :param int offset: Offset defaults to 0 if input is invalid. (Optional)
        :param str accept: JSON, XML or CSV can be returned (Optional)
        :return: TradeCoinWithdrawDataResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.v1userexchangebankcoinwithdrawverified_with_http_info(authorization, **kwargs)
        else:
            (data) = self.v1userexchangebankcoinwithdrawverified_with_http_info(authorization, **kwargs)
            return data

    def v1userexchangebankcoinwithdrawverified_with_http_info(self, authorization, **kwargs):
        """
        Verified Exchange Coin Withdrawals
        Gets a List of Verified Exchange Coin Withdrawals. The value and fees are in satoshis.

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

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str authorization: API object to be added (required)
        :param int _from: From date in Epoch, defaults to 0 if invalid input or greater than current time. (Optional)
        :param int to: To Date in Epoch, defaults to current time if invalid input or greater than current time. (Optional)
        :param int max: Max defaults to 10 if invalid input and defaults to 100 if greater than 100. (Optional)
        :param int offset: Offset defaults to 0 if input is invalid. (Optional)
        :param str accept: JSON, XML or CSV can be returned (Optional)
        :return: TradeCoinWithdrawDataResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['authorization', '_from', 'to', 'max', 'offset', 'accept']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

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


        collection_formats = {}

        resource_path = '/v1/user/exchange/bank/coin/withdraw/verified'.replace('{format}', 'json')
        path_params = {}

        query_params = {}
        if '_from' in params:
            query_params['from'] = params['_from']
        if 'to' in params:
            query_params['to'] = params['to']
        if 'max' in params:
            query_params['max'] = params['max']
        if 'offset' in params:
            query_params['offset'] = params['offset']

        header_params = {}
        if 'authorization' in params:
            header_params['Authorization'] = params['authorization']
        if 'accept' in params:
            header_params['accept'] = params['accept']

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json', 'application/xml', 'application/csv'])
        if not header_params['Accept']:
            del header_params['Accept']

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

        # Authentication setting
        auth_settings = []

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