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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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