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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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