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

// 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 *bequant) PublicGetPublicCurrency (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("publicGetPublicCurrency", parameters))
       PanicOnError(ch)
   }()
   return ch
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (this *bequant) 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 *bequant) PrivateGetMarginAccountIsolatedSymbol (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privateGetMarginAccountIsolatedSymbol", parameters))
       PanicOnError(ch)
   }()
   return ch
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (this *bequant) 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 *bequant) PrivatePostMarginOrderList (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostMarginOrderList", parameters))
       PanicOnError(ch)
   }()
   return ch
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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