// -------------------------------------------------------------------------------

// PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
// https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code

// -------------------------------------------------------------------------------

package ccxt

func (this *independentreserve) PublicGetGetValidPrimaryCurrencyCodes (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("publicGetGetValidPrimaryCurrencyCodes", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *independentreserve) PublicGetGetValidSecondaryCurrencyCodes (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("publicGetGetValidSecondaryCurrencyCodes", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *independentreserve) PublicGetGetValidLimitOrderTypes (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("publicGetGetValidLimitOrderTypes", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *independentreserve) PublicGetGetValidMarketOrderTypes (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("publicGetGetValidMarketOrderTypes", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *independentreserve) PublicGetGetValidOrderTypes (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("publicGetGetValidOrderTypes", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *independentreserve) PublicGetGetValidTransactionTypes (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("publicGetGetValidTransactionTypes", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *independentreserve) PublicGetGetMarketSummary (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("publicGetGetMarketSummary", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *independentreserve) PublicGetGetOrderBook (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("publicGetGetOrderBook", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *independentreserve) PublicGetGetAllOrders (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("publicGetGetAllOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *independentreserve) PublicGetGetTradeHistorySummary (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("publicGetGetTradeHistorySummary", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *independentreserve) PublicGetGetRecentTrades (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("publicGetGetRecentTrades", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *independentreserve) PublicGetGetFxRates (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("publicGetGetFxRates", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *independentreserve) PublicGetGetOrderMinimumVolumes (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("publicGetGetOrderMinimumVolumes", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *independentreserve) PublicGetGetCryptoWithdrawalFees (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("publicGetGetCryptoWithdrawalFees", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *independentreserve) PublicGetGetCryptoWithdrawalFees2 (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("publicGetGetCryptoWithdrawalFees2", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *independentreserve) PublicGetGetNetworks (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("publicGetGetNetworks", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *independentreserve) PublicGetGetPrimaryCurrencyConfig2 (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("publicGetGetPrimaryCurrencyConfig2", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *independentreserve) PrivatePostGetOpenOrders (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostGetOpenOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *independentreserve) PrivatePostGetClosedOrders (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostGetClosedOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *independentreserve) PrivatePostGetClosedFilledOrders (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostGetClosedFilledOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *independentreserve) PrivatePostGetOrderDetails (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostGetOrderDetails", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *independentreserve) PrivatePostGetAccounts (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostGetAccounts", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *independentreserve) PrivatePostGetTransactions (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostGetTransactions", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *independentreserve) PrivatePostGetFiatBankAccounts (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostGetFiatBankAccounts", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *independentreserve) PrivatePostGetDigitalCurrencyDepositAddress (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostGetDigitalCurrencyDepositAddress", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *independentreserve) PrivatePostGetDigitalCurrencyDepositAddress2 (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostGetDigitalCurrencyDepositAddress2", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *independentreserve) PrivatePostGetDigitalCurrencyDepositAddresses (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostGetDigitalCurrencyDepositAddresses", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *independentreserve) PrivatePostGetDigitalCurrencyDepositAddresses2 (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostGetDigitalCurrencyDepositAddresses2", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *independentreserve) PrivatePostGetTrades (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostGetTrades", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *independentreserve) PrivatePostGetBrokerageFees (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostGetBrokerageFees", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *independentreserve) PrivatePostGetDigitalCurrencyWithdrawal (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostGetDigitalCurrencyWithdrawal", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *independentreserve) PrivatePostPlaceLimitOrder (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostPlaceLimitOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *independentreserve) PrivatePostPlaceMarketOrder (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostPlaceMarketOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *independentreserve) PrivatePostCancelOrder (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostCancelOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *independentreserve) PrivatePostSynchDigitalCurrencyDepositAddressWithBlockchain (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostSynchDigitalCurrencyDepositAddressWithBlockchain", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *independentreserve) PrivatePostRequestFiatWithdrawal (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostRequestFiatWithdrawal", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *independentreserve) PrivatePostWithdrawFiatCurrency (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostWithdrawFiatCurrency", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *independentreserve) PrivatePostWithdrawDigitalCurrency (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostWithdrawDigitalCurrency", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *independentreserve) PrivatePostWithdrawCrypto (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostWithdrawCrypto", parameters))
       PanicOnError(ch)
   }()
   return ch
}