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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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