# 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 ExchangeBankActionsApi(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 v1userexchangebankcoinwithdrawinitiate(self, body, **kwargs):
        """
        Initiate Bitcoin Withdrawal
        The code for verifying the withdrawal can be called from /v1/exchange/bank/coin/withdrawVerifycode. May require a 2FA code if 2FA is enabled on the account. A mail is sent to the users email requesting confirmation of the withdrawal. This confirmation mail can be disabled on the Coinsecure Profile page.

        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.v1userexchangebankcoinwithdrawinitiate(body, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param SendCoin body: Please send the form with valid inputs. (required)
        :param str authorization: Enter a valid Api Key.
        :param str accept: JSON, XML or CSV can be returned (Optional)
        :return: SuccessResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.v1userexchangebankcoinwithdrawinitiate_with_http_info(body, **kwargs)
        else:
            (data) = self.v1userexchangebankcoinwithdrawinitiate_with_http_info(body, **kwargs)
            return data

    def v1userexchangebankcoinwithdrawinitiate_with_http_info(self, body, **kwargs):
        """
        Initiate Bitcoin Withdrawal
        The code for verifying the withdrawal can be called from /v1/exchange/bank/coin/withdrawVerifycode. May require a 2FA code if 2FA is enabled on the account. A mail is sent to the users email requesting confirmation of the withdrawal. This confirmation mail can be disabled on the Coinsecure Profile page.

        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.v1userexchangebankcoinwithdrawinitiate_with_http_info(body, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param SendCoin body: Please send the form with valid inputs. (required)
        :param str authorization: Enter a valid Api Key.
        :param str accept: JSON, XML or CSV can be returned (Optional)
        :return: SuccessResult
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['body', '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 v1userexchangebankcoinwithdrawinitiate" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'body' is set
        if ('body' not in params) or (params['body'] is None):
            raise ValueError("Missing the required parameter `body` when calling `v1userexchangebankcoinwithdrawinitiate`")


        collection_formats = {}

        resource_path = '/v1/user/exchange/bank/coin/withdraw/initiate'.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
        if 'body' in params:
            body_params = params['body']

        # 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, 'POST',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='SuccessResult',
                                            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 v1userexchangebankcoinwithdrawnew_verifycode(self, body, **kwargs):
        """
        Gets a Verification Code.
        Gets Coin Unverified Withdraws Codes to call and apply on /v1/user/exchange/bank/coin/withdraw/verify.

        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.v1userexchangebankcoinwithdrawnew_verifycode(body, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param WithdrawID body: You can get unverified withdraw ID's from /v1/user/exchange/bank/coin/withdraw/unverified (required)
        :param str authorization: API object to be added
        :param str accept: JSON, XML or CSV can be returned (Optional)
        :return: SuccessResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.v1userexchangebankcoinwithdrawnew_verifycode_with_http_info(body, **kwargs)
        else:
            (data) = self.v1userexchangebankcoinwithdrawnew_verifycode_with_http_info(body, **kwargs)
            return data

    def v1userexchangebankcoinwithdrawnew_verifycode_with_http_info(self, body, **kwargs):
        """
        Gets a Verification Code.
        Gets Coin Unverified Withdraws Codes to call and apply on /v1/user/exchange/bank/coin/withdraw/verify.

        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.v1userexchangebankcoinwithdrawnew_verifycode_with_http_info(body, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param WithdrawID body: You can get unverified withdraw ID's from /v1/user/exchange/bank/coin/withdraw/unverified (required)
        :param str authorization: API object to be added
        :param str accept: JSON, XML or CSV can be returned (Optional)
        :return: SuccessResult
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['body', '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 v1userexchangebankcoinwithdrawnew_verifycode" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'body' is set
        if ('body' not in params) or (params['body'] is None):
            raise ValueError("Missing the required parameter `body` when calling `v1userexchangebankcoinwithdrawnew_verifycode`")


        collection_formats = {}

        resource_path = '/v1/user/exchange/bank/coin/withdraw/newVerifycode'.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
        if 'body' in params:
            body_params = params['body']

        # 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, 'POST',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='SuccessResult',
                                            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 v1userexchangebankcoinwithdrawunverifiedcancel_withdraw_id(self, withdraw_id, **kwargs):
        """
        Cancel Bitcoin Withdrawal
        Cancels an unverified withdrawal. You can get the WithdrawID from /v1/user/exchange/bank/coin/withdraw/unverified.

        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.v1userexchangebankcoinwithdrawunverifiedcancel_withdraw_id(withdraw_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str withdraw_id:  (required)
        :param str authorization: Enter a valid Api Key.
        :param str accept: JSON, XML or CSV can be returned (Optional)
        :return: SuccessResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.v1userexchangebankcoinwithdrawunverifiedcancel_withdraw_id_with_http_info(withdraw_id, **kwargs)
        else:
            (data) = self.v1userexchangebankcoinwithdrawunverifiedcancel_withdraw_id_with_http_info(withdraw_id, **kwargs)
            return data

    def v1userexchangebankcoinwithdrawunverifiedcancel_withdraw_id_with_http_info(self, withdraw_id, **kwargs):
        """
        Cancel Bitcoin Withdrawal
        Cancels an unverified withdrawal. You can get the WithdrawID from /v1/user/exchange/bank/coin/withdraw/unverified.

        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.v1userexchangebankcoinwithdrawunverifiedcancel_withdraw_id_with_http_info(withdraw_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str withdraw_id:  (required)
        :param str authorization: Enter a valid Api Key.
        :param str accept: JSON, XML or CSV can be returned (Optional)
        :return: SuccessResult
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['withdraw_id', '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 v1userexchangebankcoinwithdrawunverifiedcancel_withdraw_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'withdraw_id' is set
        if ('withdraw_id' not in params) or (params['withdraw_id'] is None):
            raise ValueError("Missing the required parameter `withdraw_id` when calling `v1userexchangebankcoinwithdrawunverifiedcancel_withdraw_id`")


        collection_formats = {}

        resource_path = '/v1/user/exchange/bank/coin/withdraw/unverified/cancel/{withdrawID}'.replace('{format}', 'json')
        path_params = {}
        if 'withdraw_id' in params:
            path_params['withdrawID'] = params['withdraw_id']

        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, 'DELETE',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='SuccessResult',
                                            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 v1userexchangebankcoinwithdrawverify(self, body, **kwargs):
        """
        Verify Bitcoin Withdrawal
        Verifies an unverified withdrawal. You can get the code from /v1/user/exchange/bank/coin/withdraw/newVerifycode.

        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.v1userexchangebankcoinwithdrawverify(body, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param Code body: You can get the code from /v1/user/exchange/bank/coin/withdraw/newVerifycode. (required)
        :param str authorization: Enter a valid Api Key.
        :param str accept: JSON, XML or CSV can be returned (Optional)
        :return: SuccessResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.v1userexchangebankcoinwithdrawverify_with_http_info(body, **kwargs)
        else:
            (data) = self.v1userexchangebankcoinwithdrawverify_with_http_info(body, **kwargs)
            return data

    def v1userexchangebankcoinwithdrawverify_with_http_info(self, body, **kwargs):
        """
        Verify Bitcoin Withdrawal
        Verifies an unverified withdrawal. You can get the code from /v1/user/exchange/bank/coin/withdraw/newVerifycode.

        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.v1userexchangebankcoinwithdrawverify_with_http_info(body, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param Code body: You can get the code from /v1/user/exchange/bank/coin/withdraw/newVerifycode. (required)
        :param str authorization: Enter a valid Api Key.
        :param str accept: JSON, XML or CSV can be returned (Optional)
        :return: SuccessResult
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['body', '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 v1userexchangebankcoinwithdrawverify" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'body' is set
        if ('body' not in params) or (params['body'] is None):
            raise ValueError("Missing the required parameter `body` when calling `v1userexchangebankcoinwithdrawverify`")


        collection_formats = {}

        resource_path = '/v1/user/exchange/bank/coin/withdraw/verify'.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
        if 'body' in params:
            body_params = params['body']

        # 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, 'PUT',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='SuccessResult',
                                            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 v1userexchangebankfiataccountnew(self, body, **kwargs):
        """
        New Bank Link
        Submits a New Bank Link on KYC Verified Accounts.

        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.v1userexchangebankfiataccountnew(body, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param NewBankForm body: Please send the form with valid inputs. (required)
        :param str authorization: Enter a valid Api Key.
        :param str accept: JSON, XML or CSV can be returned (Optional)
        :return: SuccessResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.v1userexchangebankfiataccountnew_with_http_info(body, **kwargs)
        else:
            (data) = self.v1userexchangebankfiataccountnew_with_http_info(body, **kwargs)
            return data

    def v1userexchangebankfiataccountnew_with_http_info(self, body, **kwargs):
        """
        New Bank Link
        Submits a New Bank Link on KYC Verified Accounts.

        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.v1userexchangebankfiataccountnew_with_http_info(body, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param NewBankForm body: Please send the form with valid inputs. (required)
        :param str authorization: Enter a valid Api Key.
        :param str accept: JSON, XML or CSV can be returned (Optional)
        :return: SuccessResult
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['body', '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 v1userexchangebankfiataccountnew" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'body' is set
        if ('body' not in params) or (params['body'] is None):
            raise ValueError("Missing the required parameter `body` when calling `v1userexchangebankfiataccountnew`")


        collection_formats = {}

        resource_path = '/v1/user/exchange/bank/fiat/account/new'.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
        if 'body' in params:
            body_params = params['body']

        # 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, 'PUT',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='SuccessResult',
                                            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 v1userexchangebankfiatdepositcancel_deposit_id(self, deposit_id, **kwargs):
        """
        Cancel Unverified Exchange Fiat Deposit
        Cancels an unverified Exchange Fiat Deposit.

        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.v1userexchangebankfiatdepositcancel_deposit_id(deposit_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str deposit_id:  (required)
        :param str authorization: Enter a valid Api Key.
        :param str accept: JSON, XML or CSV can be returned (Optional)
        :return: SuccessResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.v1userexchangebankfiatdepositcancel_deposit_id_with_http_info(deposit_id, **kwargs)
        else:
            (data) = self.v1userexchangebankfiatdepositcancel_deposit_id_with_http_info(deposit_id, **kwargs)
            return data

    def v1userexchangebankfiatdepositcancel_deposit_id_with_http_info(self, deposit_id, **kwargs):
        """
        Cancel Unverified Exchange Fiat Deposit
        Cancels an unverified Exchange Fiat Deposit.

        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.v1userexchangebankfiatdepositcancel_deposit_id_with_http_info(deposit_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str deposit_id:  (required)
        :param str authorization: Enter a valid Api Key.
        :param str accept: JSON, XML or CSV can be returned (Optional)
        :return: SuccessResult
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['deposit_id', '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 v1userexchangebankfiatdepositcancel_deposit_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'deposit_id' is set
        if ('deposit_id' not in params) or (params['deposit_id'] is None):
            raise ValueError("Missing the required parameter `deposit_id` when calling `v1userexchangebankfiatdepositcancel_deposit_id`")


        collection_formats = {}

        resource_path = '/v1/user/exchange/bank/fiat/deposit/cancel/{depositID}'.replace('{format}', 'json')
        path_params = {}
        if 'deposit_id' in params:
            path_params['depositID'] = params['deposit_id']

        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, 'DELETE',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='SuccessResult',
                                            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 v1userexchangebankfiatdepositnew(self, body, **kwargs):
        """
        New Exchange Fiat Deposit
        Submits an unverified fiat deposit. No action will occur unless user cancels or bank notifies us of the payment.

        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.v1userexchangebankfiatdepositnew(body, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param NewFiatBankDeposit body: Please send the form with valid inputs. (required)
        :param str authorization: Enter a valid Api Key.
        :param str accept: JSON, XML or CSV can be returned (Optional)
        :return: SuccessResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.v1userexchangebankfiatdepositnew_with_http_info(body, **kwargs)
        else:
            (data) = self.v1userexchangebankfiatdepositnew_with_http_info(body, **kwargs)
            return data

    def v1userexchangebankfiatdepositnew_with_http_info(self, body, **kwargs):
        """
        New Exchange Fiat Deposit
        Submits an unverified fiat deposit. No action will occur unless user cancels or bank notifies us of the payment.

        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.v1userexchangebankfiatdepositnew_with_http_info(body, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param NewFiatBankDeposit body: Please send the form with valid inputs. (required)
        :param str authorization: Enter a valid Api Key.
        :param str accept: JSON, XML or CSV can be returned (Optional)
        :return: SuccessResult
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['body', '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 v1userexchangebankfiatdepositnew" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'body' is set
        if ('body' not in params) or (params['body'] is None):
            raise ValueError("Missing the required parameter `body` when calling `v1userexchangebankfiatdepositnew`")


        collection_formats = {}

        resource_path = '/v1/user/exchange/bank/fiat/deposit/new'.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
        if 'body' in params:
            body_params = params['body']

        # 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, 'PUT',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='SuccessResult',
                                            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 v1userexchangebankfiatwithdrawinitiate(self, body, **kwargs):
        """
        Initiate Fiat Withdrawal
        The code for verifying the withdrawal can be called from /v1/user/exchange/bank/fiat/withdraw/newVerifycode. May require a 2FA code if 2FA is enabled on the account. A mail is sent to the users email requesting confirmation of the withdrawal. This confirmation mail can be disabled on the Coinsecure Profile page.

        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.v1userexchangebankfiatwithdrawinitiate(body, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param WithdrawFiat body: Please send the form with valid inputs. (required)
        :param str authorization: Enter a valid Api Key.
        :param str accept: JSON, XML or CSV can be returned (Optional)
        :return: SuccessResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.v1userexchangebankfiatwithdrawinitiate_with_http_info(body, **kwargs)
        else:
            (data) = self.v1userexchangebankfiatwithdrawinitiate_with_http_info(body, **kwargs)
            return data

    def v1userexchangebankfiatwithdrawinitiate_with_http_info(self, body, **kwargs):
        """
        Initiate Fiat Withdrawal
        The code for verifying the withdrawal can be called from /v1/user/exchange/bank/fiat/withdraw/newVerifycode. May require a 2FA code if 2FA is enabled on the account. A mail is sent to the users email requesting confirmation of the withdrawal. This confirmation mail can be disabled on the Coinsecure Profile page.

        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.v1userexchangebankfiatwithdrawinitiate_with_http_info(body, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param WithdrawFiat body: Please send the form with valid inputs. (required)
        :param str authorization: Enter a valid Api Key.
        :param str accept: JSON, XML or CSV can be returned (Optional)
        :return: SuccessResult
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['body', '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 v1userexchangebankfiatwithdrawinitiate" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'body' is set
        if ('body' not in params) or (params['body'] is None):
            raise ValueError("Missing the required parameter `body` when calling `v1userexchangebankfiatwithdrawinitiate`")


        collection_formats = {}

        resource_path = '/v1/user/exchange/bank/fiat/withdraw/initiate'.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
        if 'body' in params:
            body_params = params['body']

        # 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, 'POST',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='SuccessResult',
                                            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 v1userexchangebankfiatwithdrawnew_verifycode(self, body, **kwargs):
        """
        Gets a Fiat Verification Code.
        Gets Fiat Unverified Withdraws Codes to call and apply on /v1/user/exchange/bank/fiat/withdraw/verify.

        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.v1userexchangebankfiatwithdrawnew_verifycode(body, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param WithdrawID body: You can get unverified withdraw ID's from /v1/user/exchange/bank/fiat/withdraw/unverified (required)
        :param str authorization: API object to be added
        :param str accept: JSON, XML or CSV can be returned (Optional)
        :return: SuccessResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.v1userexchangebankfiatwithdrawnew_verifycode_with_http_info(body, **kwargs)
        else:
            (data) = self.v1userexchangebankfiatwithdrawnew_verifycode_with_http_info(body, **kwargs)
            return data

    def v1userexchangebankfiatwithdrawnew_verifycode_with_http_info(self, body, **kwargs):
        """
        Gets a Fiat Verification Code.
        Gets Fiat Unverified Withdraws Codes to call and apply on /v1/user/exchange/bank/fiat/withdraw/verify.

        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.v1userexchangebankfiatwithdrawnew_verifycode_with_http_info(body, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param WithdrawID body: You can get unverified withdraw ID's from /v1/user/exchange/bank/fiat/withdraw/unverified (required)
        :param str authorization: API object to be added
        :param str accept: JSON, XML or CSV can be returned (Optional)
        :return: SuccessResult
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['body', '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 v1userexchangebankfiatwithdrawnew_verifycode" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'body' is set
        if ('body' not in params) or (params['body'] is None):
            raise ValueError("Missing the required parameter `body` when calling `v1userexchangebankfiatwithdrawnew_verifycode`")


        collection_formats = {}

        resource_path = '/v1/user/exchange/bank/fiat/withdraw/newVerifycode'.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
        if 'body' in params:
            body_params = params['body']

        # 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, 'POST',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='SuccessResult',
                                            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 v1userexchangebankfiatwithdrawunverifiedcancel_withdraw_id(self, withdraw_id, **kwargs):
        """
        Cancel Fiat Withdrawal
        Cancels an unverified withdrawal. You can get the WithdrawID from /v1/user/exchange/bank/fiat/withdraw/unverified.

        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.v1userexchangebankfiatwithdrawunverifiedcancel_withdraw_id(withdraw_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str withdraw_id:  (required)
        :param str authorization: Enter a valid Api Key.
        :param str accept: JSON, XML or CSV can be returned (Optional)
        :return: SuccessResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.v1userexchangebankfiatwithdrawunverifiedcancel_withdraw_id_with_http_info(withdraw_id, **kwargs)
        else:
            (data) = self.v1userexchangebankfiatwithdrawunverifiedcancel_withdraw_id_with_http_info(withdraw_id, **kwargs)
            return data

    def v1userexchangebankfiatwithdrawunverifiedcancel_withdraw_id_with_http_info(self, withdraw_id, **kwargs):
        """
        Cancel Fiat Withdrawal
        Cancels an unverified withdrawal. You can get the WithdrawID from /v1/user/exchange/bank/fiat/withdraw/unverified.

        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.v1userexchangebankfiatwithdrawunverifiedcancel_withdraw_id_with_http_info(withdraw_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str withdraw_id:  (required)
        :param str authorization: Enter a valid Api Key.
        :param str accept: JSON, XML or CSV can be returned (Optional)
        :return: SuccessResult
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['withdraw_id', '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 v1userexchangebankfiatwithdrawunverifiedcancel_withdraw_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'withdraw_id' is set
        if ('withdraw_id' not in params) or (params['withdraw_id'] is None):
            raise ValueError("Missing the required parameter `withdraw_id` when calling `v1userexchangebankfiatwithdrawunverifiedcancel_withdraw_id`")


        collection_formats = {}

        resource_path = '/v1/user/exchange/bank/fiat/withdraw/unverified/cancel/{withdrawID}'.replace('{format}', 'json')
        path_params = {}
        if 'withdraw_id' in params:
            path_params['withdrawID'] = params['withdraw_id']

        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, 'DELETE',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='SuccessResult',
                                            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 v1userexchangebankfiatwithdrawverify(self, body, **kwargs):
        """
        Verify Fiat Withdrawal
        Verifies an unverified withdrawal. You can get the code from /v1/user/exchange/bank/fiat/withdraw/newVerifycode.

        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.v1userexchangebankfiatwithdrawverify(body, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param Code body: You can get the code from /v1/user/exchange/bank/fiat/withdraw/newVerifycode (required)
        :param str authorization: Enter a valid Api Key.
        :param str accept: JSON, XML or CSV can be returned (Optional)
        :return: SuccessResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.v1userexchangebankfiatwithdrawverify_with_http_info(body, **kwargs)
        else:
            (data) = self.v1userexchangebankfiatwithdrawverify_with_http_info(body, **kwargs)
            return data

    def v1userexchangebankfiatwithdrawverify_with_http_info(self, body, **kwargs):
        """
        Verify Fiat Withdrawal
        Verifies an unverified withdrawal. You can get the code from /v1/user/exchange/bank/fiat/withdraw/newVerifycode.

        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.v1userexchangebankfiatwithdrawverify_with_http_info(body, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param Code body: You can get the code from /v1/user/exchange/bank/fiat/withdraw/newVerifycode (required)
        :param str authorization: Enter a valid Api Key.
        :param str accept: JSON, XML or CSV can be returned (Optional)
        :return: SuccessResult
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['body', '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 v1userexchangebankfiatwithdrawverify" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'body' is set
        if ('body' not in params) or (params['body'] is None):
            raise ValueError("Missing the required parameter `body` when calling `v1userexchangebankfiatwithdrawverify`")


        collection_formats = {}

        resource_path = '/v1/user/exchange/bank/fiat/withdraw/verify'.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
        if 'body' in params:
            body_params = params['body']

        # 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, 'PUT',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='SuccessResult',
                                            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)
