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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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