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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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