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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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