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

// 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 *kucoin) PublicGetCurrencies (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 ("publicGetCurrencies", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PublicGetCurrenciesCurrency (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 ("publicGetCurrenciesCurrency", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PublicGetSymbols (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 ("publicGetSymbols", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PublicGetMarketOrderbookLevel1 (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 ("publicGetMarketOrderbookLevel1", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PublicGetMarketAllTickers (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 ("publicGetMarketAllTickers", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PublicGetMarketStats (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 ("publicGetMarketStats", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PublicGetMarkets (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 ("publicGetMarkets", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PublicGetMarketOrderbookLevelLevelLimit (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 ("publicGetMarketOrderbookLevelLevelLimit", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PublicGetMarketOrderbookLevel220 (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 ("publicGetMarketOrderbookLevel220", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PublicGetMarketOrderbookLevel2100 (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 ("publicGetMarketOrderbookLevel2100", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PublicGetMarketHistories (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 ("publicGetMarketHistories", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PublicGetMarketCandles (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 ("publicGetMarketCandles", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PublicGetPrices (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 ("publicGetPrices", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PublicGetTimestamp (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 ("publicGetTimestamp", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PublicGetStatus (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 ("publicGetStatus", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PublicGetMarkPriceSymbolCurrent (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 ("publicGetMarkPriceSymbolCurrent", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PublicGetMarkPriceAllSymbols (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 ("publicGetMarkPriceAllSymbols", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PublicGetMarginConfig (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 ("publicGetMarginConfig", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PublicGetAnnouncements (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 ("publicGetAnnouncements", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PublicPostBulletPublic (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 ("publicPostBulletPublic", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetUserInfo (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 ("privateGetUserInfo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetAccounts (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 ("privateGetAccounts", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetAccountsAccountId (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 ("privateGetAccountsAccountId", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetAccountsLedgers (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 ("privateGetAccountsLedgers", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetHfAccountsLedgers (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 ("privateGetHfAccountsLedgers", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetHfMarginAccountLedgers (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 ("privateGetHfMarginAccountLedgers", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetTransactionHistory (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 ("privateGetTransactionHistory", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetSubUser (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 ("privateGetSubUser", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetSubAccountsSubUserId (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 ("privateGetSubAccountsSubUserId", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetSubAccounts (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 ("privateGetSubAccounts", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetSubApiKey (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 ("privateGetSubApiKey", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetMarginAccount (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 ("privateGetMarginAccount", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetMarginAccounts (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 ("privateGetMarginAccounts", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetIsolatedAccounts (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 ("privateGetIsolatedAccounts", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetDepositAddresses (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 ("privateGetDepositAddresses", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetDeposits (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 ("privateGetDeposits", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetHistDeposits (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 ("privateGetHistDeposits", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetWithdrawals (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 ("privateGetWithdrawals", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetHistWithdrawals (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 ("privateGetHistWithdrawals", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetWithdrawalsQuotas (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 ("privateGetWithdrawalsQuotas", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetAccountsTransferable (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 ("privateGetAccountsTransferable", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetTransferList (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 ("privateGetTransferList", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetBaseFee (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 ("privateGetBaseFee", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetTradeFees (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 ("privateGetTradeFees", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetMarketOrderbookLevelLevel (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 ("privateGetMarketOrderbookLevelLevel", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetMarketOrderbookLevel2 (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 ("privateGetMarketOrderbookLevel2", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetMarketOrderbookLevel3 (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 ("privateGetMarketOrderbookLevel3", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetHfAccountsOpened (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 ("privateGetHfAccountsOpened", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetHfOrdersActive (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 ("privateGetHfOrdersActive", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetHfOrdersActiveSymbols (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 ("privateGetHfOrdersActiveSymbols", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetHfMarginOrderActiveSymbols (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 ("privateGetHfMarginOrderActiveSymbols", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetHfOrdersDone (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 ("privateGetHfOrdersDone", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetHfOrdersOrderId (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 ("privateGetHfOrdersOrderId", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetHfOrdersClientOrderClientOid (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 ("privateGetHfOrdersClientOrderClientOid", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetHfOrdersDeadCancelAllQuery (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 ("privateGetHfOrdersDeadCancelAllQuery", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetHfFills (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 ("privateGetHfFills", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetOrders (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 ("privateGetOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetLimitOrders (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 ("privateGetLimitOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetOrdersOrderId (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 ("privateGetOrdersOrderId", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetOrderClientOrderClientOid (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 ("privateGetOrderClientOrderClientOid", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetFills (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 ("privateGetFills", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetLimitFills (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 ("privateGetLimitFills", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetStopOrder (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 ("privateGetStopOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetStopOrderOrderId (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 ("privateGetStopOrderOrderId", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetStopOrderQueryOrderByClientOid (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 ("privateGetStopOrderQueryOrderByClientOid", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetOcoOrderOrderId (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 ("privateGetOcoOrderOrderId", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetOcoOrderDetailsOrderId (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 ("privateGetOcoOrderDetailsOrderId", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetOcoClientOrderClientOid (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 ("privateGetOcoClientOrderClientOid", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetOcoOrders (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 ("privateGetOcoOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetHfMarginOrdersActive (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 ("privateGetHfMarginOrdersActive", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetHfMarginOrdersDone (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 ("privateGetHfMarginOrdersDone", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetHfMarginOrdersOrderId (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 ("privateGetHfMarginOrdersOrderId", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetHfMarginOrdersClientOrderClientOid (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 ("privateGetHfMarginOrdersClientOrderClientOid", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetHfMarginFills (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 ("privateGetHfMarginFills", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetEtfInfo (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 ("privateGetEtfInfo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetMarginCurrencies (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 ("privateGetMarginCurrencies", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetRiskLimitStrategy (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 ("privateGetRiskLimitStrategy", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetIsolatedSymbols (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 ("privateGetIsolatedSymbols", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetMarginSymbols (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 ("privateGetMarginSymbols", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetIsolatedAccountSymbol (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 ("privateGetIsolatedAccountSymbol", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetMarginBorrow (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 ("privateGetMarginBorrow", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetMarginRepay (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 ("privateGetMarginRepay", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetMarginInterest (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 ("privateGetMarginInterest", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetProjectList (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 ("privateGetProjectList", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetProjectMarketInterestRate (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 ("privateGetProjectMarketInterestRate", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetRedeemOrders (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 ("privateGetRedeemOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetPurchaseOrders (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 ("privateGetPurchaseOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetBrokerApiRebaseDownload (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 ("privateGetBrokerApiRebaseDownload", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetMigrateUserAccountStatus (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 ("privateGetMigrateUserAccountStatus", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateGetAffiliateInviterStatistics (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 ("privateGetAffiliateInviterStatistics", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivatePostSubUserCreated (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 ("privatePostSubUserCreated", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivatePostSubApiKey (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 ("privatePostSubApiKey", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivatePostSubApiKeyUpdate (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 ("privatePostSubApiKeyUpdate", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivatePostDepositAddresses (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 ("privatePostDepositAddresses", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivatePostWithdrawals (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 ("privatePostWithdrawals", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivatePostAccountsUniversalTransfer (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 ("privatePostAccountsUniversalTransfer", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivatePostAccountsSubTransfer (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 ("privatePostAccountsSubTransfer", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivatePostAccountsInnerTransfer (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 ("privatePostAccountsInnerTransfer", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivatePostTransferOut (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 ("privatePostTransferOut", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivatePostTransferIn (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 ("privatePostTransferIn", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivatePostHfOrders (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 ("privatePostHfOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivatePostHfOrdersTest (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 ("privatePostHfOrdersTest", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivatePostHfOrdersSync (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 ("privatePostHfOrdersSync", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivatePostHfOrdersMulti (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 ("privatePostHfOrdersMulti", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivatePostHfOrdersMultiSync (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 ("privatePostHfOrdersMultiSync", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivatePostHfOrdersAlter (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 ("privatePostHfOrdersAlter", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivatePostHfOrdersDeadCancelAll (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 ("privatePostHfOrdersDeadCancelAll", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivatePostOrders (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 ("privatePostOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivatePostOrdersTest (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 ("privatePostOrdersTest", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivatePostOrdersMulti (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 ("privatePostOrdersMulti", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivatePostStopOrder (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 ("privatePostStopOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivatePostOcoOrder (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 ("privatePostOcoOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivatePostHfMarginOrder (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 ("privatePostHfMarginOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivatePostHfMarginOrderTest (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 ("privatePostHfMarginOrderTest", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivatePostMarginOrder (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 ("privatePostMarginOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivatePostMarginOrderTest (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 ("privatePostMarginOrderTest", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivatePostMarginBorrow (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 ("privatePostMarginBorrow", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivatePostMarginRepay (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 ("privatePostMarginRepay", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivatePostPurchase (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 ("privatePostPurchase", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivatePostRedeem (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 ("privatePostRedeem", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivatePostLendPurchaseUpdate (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 ("privatePostLendPurchaseUpdate", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivatePostBulletPrivate (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 ("privatePostBulletPrivate", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivatePostPositionUpdateUserLeverage (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 ("privatePostPositionUpdateUserLeverage", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivatePostDepositAddressCreate (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 ("privatePostDepositAddressCreate", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateDeleteSubApiKey (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 ("privateDeleteSubApiKey", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateDeleteWithdrawalsWithdrawalId (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 ("privateDeleteWithdrawalsWithdrawalId", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateDeleteHfOrdersOrderId (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 ("privateDeleteHfOrdersOrderId", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateDeleteHfOrdersSyncOrderId (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 ("privateDeleteHfOrdersSyncOrderId", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateDeleteHfOrdersClientOrderClientOid (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 ("privateDeleteHfOrdersClientOrderClientOid", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateDeleteHfOrdersSyncClientOrderClientOid (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 ("privateDeleteHfOrdersSyncClientOrderClientOid", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateDeleteHfOrdersCancelOrderId (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 ("privateDeleteHfOrdersCancelOrderId", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateDeleteHfOrders (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 ("privateDeleteHfOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateDeleteHfOrdersCancelAll (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 ("privateDeleteHfOrdersCancelAll", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateDeleteOrdersOrderId (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 ("privateDeleteOrdersOrderId", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateDeleteOrderClientOrderClientOid (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 ("privateDeleteOrderClientOrderClientOid", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateDeleteOrders (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 ("privateDeleteOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateDeleteStopOrderOrderId (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 ("privateDeleteStopOrderOrderId", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateDeleteStopOrderCancelOrderByClientOid (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 ("privateDeleteStopOrderCancelOrderByClientOid", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateDeleteStopOrderCancel (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 ("privateDeleteStopOrderCancel", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateDeleteOcoOrderOrderId (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 ("privateDeleteOcoOrderOrderId", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateDeleteOcoClientOrderClientOid (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 ("privateDeleteOcoClientOrderClientOid", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateDeleteOcoOrders (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 ("privateDeleteOcoOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateDeleteHfMarginOrdersOrderId (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 ("privateDeleteHfMarginOrdersOrderId", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateDeleteHfMarginOrdersClientOrderClientOid (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 ("privateDeleteHfMarginOrdersClientOrderClientOid", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) PrivateDeleteHfMarginOrders (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 ("privateDeleteHfMarginOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) FuturesPublicGetContractsActive (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 ("futuresPublicGetContractsActive", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) FuturesPublicGetContractsSymbol (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 ("futuresPublicGetContractsSymbol", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) FuturesPublicGetTicker (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 ("futuresPublicGetTicker", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) FuturesPublicGetLevel2Snapshot (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 ("futuresPublicGetLevel2Snapshot", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) FuturesPublicGetLevel2Depth20 (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 ("futuresPublicGetLevel2Depth20", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) FuturesPublicGetLevel2Depth100 (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 ("futuresPublicGetLevel2Depth100", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) FuturesPublicGetTradeHistory (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 ("futuresPublicGetTradeHistory", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) FuturesPublicGetKlineQuery (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 ("futuresPublicGetKlineQuery", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) FuturesPublicGetInterestQuery (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 ("futuresPublicGetInterestQuery", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) FuturesPublicGetIndexQuery (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 ("futuresPublicGetIndexQuery", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) FuturesPublicGetMarkPriceSymbolCurrent (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 ("futuresPublicGetMarkPriceSymbolCurrent", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) FuturesPublicGetPremiumQuery (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 ("futuresPublicGetPremiumQuery", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) FuturesPublicGetTradeStatistics (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 ("futuresPublicGetTradeStatistics", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) FuturesPublicGetFundingRateSymbolCurrent (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 ("futuresPublicGetFundingRateSymbolCurrent", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) FuturesPublicGetContractFundingRates (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 ("futuresPublicGetContractFundingRates", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) FuturesPublicGetTimestamp (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 ("futuresPublicGetTimestamp", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) FuturesPublicGetStatus (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 ("futuresPublicGetStatus", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) FuturesPublicGetLevel2MessageQuery (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 ("futuresPublicGetLevel2MessageQuery", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) FuturesPublicPostBulletPublic (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 ("futuresPublicPostBulletPublic", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) FuturesPrivateGetTransactionHistory (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 ("futuresPrivateGetTransactionHistory", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) FuturesPrivateGetAccountOverview (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 ("futuresPrivateGetAccountOverview", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) FuturesPrivateGetAccountOverviewAll (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 ("futuresPrivateGetAccountOverviewAll", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) FuturesPrivateGetTransferList (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 ("futuresPrivateGetTransferList", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) FuturesPrivateGetOrders (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 ("futuresPrivateGetOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) FuturesPrivateGetStopOrders (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 ("futuresPrivateGetStopOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) FuturesPrivateGetRecentDoneOrders (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 ("futuresPrivateGetRecentDoneOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) FuturesPrivateGetOrdersOrderId (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 ("futuresPrivateGetOrdersOrderId", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) FuturesPrivateGetOrdersByClientOid (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 ("futuresPrivateGetOrdersByClientOid", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) FuturesPrivateGetFills (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 ("futuresPrivateGetFills", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) FuturesPrivateGetRecentFills (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 ("futuresPrivateGetRecentFills", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) FuturesPrivateGetOpenOrderStatistics (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 ("futuresPrivateGetOpenOrderStatistics", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) FuturesPrivateGetPosition (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 ("futuresPrivateGetPosition", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) FuturesPrivateGetPositions (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 ("futuresPrivateGetPositions", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) FuturesPrivateGetMarginMaxWithdrawMargin (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 ("futuresPrivateGetMarginMaxWithdrawMargin", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) FuturesPrivateGetContractsRiskLimitSymbol (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 ("futuresPrivateGetContractsRiskLimitSymbol", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) FuturesPrivateGetFundingHistory (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 ("futuresPrivateGetFundingHistory", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) FuturesPrivatePostTransferOut (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 ("futuresPrivatePostTransferOut", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) FuturesPrivatePostTransferIn (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 ("futuresPrivatePostTransferIn", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) FuturesPrivatePostOrders (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 ("futuresPrivatePostOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) FuturesPrivatePostOrdersTest (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 ("futuresPrivatePostOrdersTest", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) FuturesPrivatePostOrdersMulti (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 ("futuresPrivatePostOrdersMulti", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) FuturesPrivatePostPositionMarginAutoDepositStatus (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 ("futuresPrivatePostPositionMarginAutoDepositStatus", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) FuturesPrivatePostMarginWithdrawMargin (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 ("futuresPrivatePostMarginWithdrawMargin", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) FuturesPrivatePostPositionMarginDepositMargin (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 ("futuresPrivatePostPositionMarginDepositMargin", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) FuturesPrivatePostPositionRiskLimitLevelChange (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 ("futuresPrivatePostPositionRiskLimitLevelChange", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) FuturesPrivatePostBulletPrivate (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 ("futuresPrivatePostBulletPrivate", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) FuturesPrivateDeleteOrdersOrderId (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 ("futuresPrivateDeleteOrdersOrderId", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) FuturesPrivateDeleteOrdersClientOrderClientOid (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 ("futuresPrivateDeleteOrdersClientOrderClientOid", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) FuturesPrivateDeleteOrders (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 ("futuresPrivateDeleteOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) FuturesPrivateDeleteStopOrders (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 ("futuresPrivateDeleteStopOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) WebExchangeGetCurrencyCurrencyChainInfo (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 ("webExchangeGetCurrencyCurrencyChainInfo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) BrokerGetBrokerNdInfo (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 ("brokerGetBrokerNdInfo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) BrokerGetBrokerNdAccount (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 ("brokerGetBrokerNdAccount", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) BrokerGetBrokerNdAccountApikey (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 ("brokerGetBrokerNdAccountApikey", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) BrokerGetBrokerNdRebaseDownload (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 ("brokerGetBrokerNdRebaseDownload", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) BrokerGetAssetNdbrokerDepositList (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 ("brokerGetAssetNdbrokerDepositList", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) BrokerGetBrokerNdTransferDetail (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 ("brokerGetBrokerNdTransferDetail", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) BrokerGetBrokerNdDepositDetail (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 ("brokerGetBrokerNdDepositDetail", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) BrokerGetBrokerNdWithdrawDetail (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 ("brokerGetBrokerNdWithdrawDetail", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) BrokerPostBrokerNdTransfer (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 ("brokerPostBrokerNdTransfer", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) BrokerPostBrokerNdAccount (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 ("brokerPostBrokerNdAccount", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) BrokerPostBrokerNdAccountApikey (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 ("brokerPostBrokerNdAccountApikey", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) BrokerPostBrokerNdAccountUpdateApikey (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 ("brokerPostBrokerNdAccountUpdateApikey", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) BrokerDeleteBrokerNdAccountApikey (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 ("brokerDeleteBrokerNdAccountApikey", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) EarnGetOtcLoanLoan (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 ("earnGetOtcLoanLoan", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) EarnGetOtcLoanAccounts (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 ("earnGetOtcLoanAccounts", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) EarnGetEarnRedeemPreview (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 ("earnGetEarnRedeemPreview", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) EarnGetEarnSavingProducts (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 ("earnGetEarnSavingProducts", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) EarnGetEarnHoldAssets (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 ("earnGetEarnHoldAssets", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) EarnGetEarnPromotionProducts (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 ("earnGetEarnPromotionProducts", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) EarnGetEarnKcsStakingProducts (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 ("earnGetEarnKcsStakingProducts", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) EarnGetEarnStakingProducts (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 ("earnGetEarnStakingProducts", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) EarnGetEarnEthStakingProducts (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 ("earnGetEarnEthStakingProducts", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) EarnPostEarnOrders (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 ("earnPostEarnOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *kucoin) EarnDeleteEarnOrders (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 ("earnDeleteEarnOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}