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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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