ccxt-go/gemini_api.go

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

// PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
// https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code

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

package ccxt

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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