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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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