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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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