ccxt-go/bybit_api.go

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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