// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.3.0
// - protoc             (unknown)
// source: rpc.proto

package gctrpc

import (
	context "context"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
)

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
// Requires gRPC-Go v1.32.0 or later.
const _ = grpc.SupportPackageIsVersion7

const (
	GoCryptoTraderService_GetInfo_FullMethodName                           = "/gctrpc.GoCryptoTraderService/GetInfo"
	GoCryptoTraderService_GetSubsystems_FullMethodName                     = "/gctrpc.GoCryptoTraderService/GetSubsystems"
	GoCryptoTraderService_EnableSubsystem_FullMethodName                   = "/gctrpc.GoCryptoTraderService/EnableSubsystem"
	GoCryptoTraderService_DisableSubsystem_FullMethodName                  = "/gctrpc.GoCryptoTraderService/DisableSubsystem"
	GoCryptoTraderService_GetRPCEndpoints_FullMethodName                   = "/gctrpc.GoCryptoTraderService/GetRPCEndpoints"
	GoCryptoTraderService_GetCommunicationRelayers_FullMethodName          = "/gctrpc.GoCryptoTraderService/GetCommunicationRelayers"
	GoCryptoTraderService_GetExchanges_FullMethodName                      = "/gctrpc.GoCryptoTraderService/GetExchanges"
	GoCryptoTraderService_DisableExchange_FullMethodName                   = "/gctrpc.GoCryptoTraderService/DisableExchange"
	GoCryptoTraderService_GetExchangeInfo_FullMethodName                   = "/gctrpc.GoCryptoTraderService/GetExchangeInfo"
	GoCryptoTraderService_GetExchangeOTPCode_FullMethodName                = "/gctrpc.GoCryptoTraderService/GetExchangeOTPCode"
	GoCryptoTraderService_GetExchangeOTPCodes_FullMethodName               = "/gctrpc.GoCryptoTraderService/GetExchangeOTPCodes"
	GoCryptoTraderService_EnableExchange_FullMethodName                    = "/gctrpc.GoCryptoTraderService/EnableExchange"
	GoCryptoTraderService_GetTicker_FullMethodName                         = "/gctrpc.GoCryptoTraderService/GetTicker"
	GoCryptoTraderService_GetTickers_FullMethodName                        = "/gctrpc.GoCryptoTraderService/GetTickers"
	GoCryptoTraderService_GetOrderbook_FullMethodName                      = "/gctrpc.GoCryptoTraderService/GetOrderbook"
	GoCryptoTraderService_GetOrderbooks_FullMethodName                     = "/gctrpc.GoCryptoTraderService/GetOrderbooks"
	GoCryptoTraderService_GetAccountInfo_FullMethodName                    = "/gctrpc.GoCryptoTraderService/GetAccountInfo"
	GoCryptoTraderService_UpdateAccountInfo_FullMethodName                 = "/gctrpc.GoCryptoTraderService/UpdateAccountInfo"
	GoCryptoTraderService_GetAccountInfoStream_FullMethodName              = "/gctrpc.GoCryptoTraderService/GetAccountInfoStream"
	GoCryptoTraderService_GetConfig_FullMethodName                         = "/gctrpc.GoCryptoTraderService/GetConfig"
	GoCryptoTraderService_GetPortfolio_FullMethodName                      = "/gctrpc.GoCryptoTraderService/GetPortfolio"
	GoCryptoTraderService_GetPortfolioSummary_FullMethodName               = "/gctrpc.GoCryptoTraderService/GetPortfolioSummary"
	GoCryptoTraderService_AddPortfolioAddress_FullMethodName               = "/gctrpc.GoCryptoTraderService/AddPortfolioAddress"
	GoCryptoTraderService_RemovePortfolioAddress_FullMethodName            = "/gctrpc.GoCryptoTraderService/RemovePortfolioAddress"
	GoCryptoTraderService_GetForexProviders_FullMethodName                 = "/gctrpc.GoCryptoTraderService/GetForexProviders"
	GoCryptoTraderService_GetForexRates_FullMethodName                     = "/gctrpc.GoCryptoTraderService/GetForexRates"
	GoCryptoTraderService_GetOrders_FullMethodName                         = "/gctrpc.GoCryptoTraderService/GetOrders"
	GoCryptoTraderService_GetOrder_FullMethodName                          = "/gctrpc.GoCryptoTraderService/GetOrder"
	GoCryptoTraderService_SubmitOrder_FullMethodName                       = "/gctrpc.GoCryptoTraderService/SubmitOrder"
	GoCryptoTraderService_SimulateOrder_FullMethodName                     = "/gctrpc.GoCryptoTraderService/SimulateOrder"
	GoCryptoTraderService_WhaleBomb_FullMethodName                         = "/gctrpc.GoCryptoTraderService/WhaleBomb"
	GoCryptoTraderService_CancelOrder_FullMethodName                       = "/gctrpc.GoCryptoTraderService/CancelOrder"
	GoCryptoTraderService_CancelBatchOrders_FullMethodName                 = "/gctrpc.GoCryptoTraderService/CancelBatchOrders"
	GoCryptoTraderService_CancelAllOrders_FullMethodName                   = "/gctrpc.GoCryptoTraderService/CancelAllOrders"
	GoCryptoTraderService_GetEvents_FullMethodName                         = "/gctrpc.GoCryptoTraderService/GetEvents"
	GoCryptoTraderService_AddEvent_FullMethodName                          = "/gctrpc.GoCryptoTraderService/AddEvent"
	GoCryptoTraderService_RemoveEvent_FullMethodName                       = "/gctrpc.GoCryptoTraderService/RemoveEvent"
	GoCryptoTraderService_GetCryptocurrencyDepositAddresses_FullMethodName = "/gctrpc.GoCryptoTraderService/GetCryptocurrencyDepositAddresses"
	GoCryptoTraderService_GetCryptocurrencyDepositAddress_FullMethodName   = "/gctrpc.GoCryptoTraderService/GetCryptocurrencyDepositAddress"
	GoCryptoTraderService_GetAvailableTransferChains_FullMethodName        = "/gctrpc.GoCryptoTraderService/GetAvailableTransferChains"
	GoCryptoTraderService_WithdrawFiatFunds_FullMethodName                 = "/gctrpc.GoCryptoTraderService/WithdrawFiatFunds"
	GoCryptoTraderService_WithdrawCryptocurrencyFunds_FullMethodName       = "/gctrpc.GoCryptoTraderService/WithdrawCryptocurrencyFunds"
	GoCryptoTraderService_WithdrawalEventByID_FullMethodName               = "/gctrpc.GoCryptoTraderService/WithdrawalEventByID"
	GoCryptoTraderService_WithdrawalEventsByExchange_FullMethodName        = "/gctrpc.GoCryptoTraderService/WithdrawalEventsByExchange"
	GoCryptoTraderService_WithdrawalEventsByDate_FullMethodName            = "/gctrpc.GoCryptoTraderService/WithdrawalEventsByDate"
	GoCryptoTraderService_GetLoggerDetails_FullMethodName                  = "/gctrpc.GoCryptoTraderService/GetLoggerDetails"
	GoCryptoTraderService_SetLoggerDetails_FullMethodName                  = "/gctrpc.GoCryptoTraderService/SetLoggerDetails"
	GoCryptoTraderService_GetExchangePairs_FullMethodName                  = "/gctrpc.GoCryptoTraderService/GetExchangePairs"
	GoCryptoTraderService_SetExchangePair_FullMethodName                   = "/gctrpc.GoCryptoTraderService/SetExchangePair"
	GoCryptoTraderService_GetOrderbookStream_FullMethodName                = "/gctrpc.GoCryptoTraderService/GetOrderbookStream"
	GoCryptoTraderService_GetExchangeOrderbookStream_FullMethodName        = "/gctrpc.GoCryptoTraderService/GetExchangeOrderbookStream"
	GoCryptoTraderService_GetTickerStream_FullMethodName                   = "/gctrpc.GoCryptoTraderService/GetTickerStream"
	GoCryptoTraderService_GetExchangeTickerStream_FullMethodName           = "/gctrpc.GoCryptoTraderService/GetExchangeTickerStream"
	GoCryptoTraderService_GetAuditEvent_FullMethodName                     = "/gctrpc.GoCryptoTraderService/GetAuditEvent"
	GoCryptoTraderService_GCTScriptExecute_FullMethodName                  = "/gctrpc.GoCryptoTraderService/GCTScriptExecute"
	GoCryptoTraderService_GCTScriptUpload_FullMethodName                   = "/gctrpc.GoCryptoTraderService/GCTScriptUpload"
	GoCryptoTraderService_GCTScriptReadScript_FullMethodName               = "/gctrpc.GoCryptoTraderService/GCTScriptReadScript"
	GoCryptoTraderService_GCTScriptStatus_FullMethodName                   = "/gctrpc.GoCryptoTraderService/GCTScriptStatus"
	GoCryptoTraderService_GCTScriptQuery_FullMethodName                    = "/gctrpc.GoCryptoTraderService/GCTScriptQuery"
	GoCryptoTraderService_GCTScriptStop_FullMethodName                     = "/gctrpc.GoCryptoTraderService/GCTScriptStop"
	GoCryptoTraderService_GCTScriptStopAll_FullMethodName                  = "/gctrpc.GoCryptoTraderService/GCTScriptStopAll"
	GoCryptoTraderService_GCTScriptListAll_FullMethodName                  = "/gctrpc.GoCryptoTraderService/GCTScriptListAll"
	GoCryptoTraderService_GCTScriptAutoLoadToggle_FullMethodName           = "/gctrpc.GoCryptoTraderService/GCTScriptAutoLoadToggle"
	GoCryptoTraderService_GetHistoricCandles_FullMethodName                = "/gctrpc.GoCryptoTraderService/GetHistoricCandles"
	GoCryptoTraderService_SetExchangeAsset_FullMethodName                  = "/gctrpc.GoCryptoTraderService/SetExchangeAsset"
	GoCryptoTraderService_SetAllExchangePairs_FullMethodName               = "/gctrpc.GoCryptoTraderService/SetAllExchangePairs"
	GoCryptoTraderService_UpdateExchangeSupportedPairs_FullMethodName      = "/gctrpc.GoCryptoTraderService/UpdateExchangeSupportedPairs"
	GoCryptoTraderService_GetExchangeAssets_FullMethodName                 = "/gctrpc.GoCryptoTraderService/GetExchangeAssets"
	GoCryptoTraderService_WebsocketGetInfo_FullMethodName                  = "/gctrpc.GoCryptoTraderService/WebsocketGetInfo"
	GoCryptoTraderService_WebsocketSetEnabled_FullMethodName               = "/gctrpc.GoCryptoTraderService/WebsocketSetEnabled"
	GoCryptoTraderService_WebsocketGetSubscriptions_FullMethodName         = "/gctrpc.GoCryptoTraderService/WebsocketGetSubscriptions"
	GoCryptoTraderService_WebsocketSetProxy_FullMethodName                 = "/gctrpc.GoCryptoTraderService/WebsocketSetProxy"
	GoCryptoTraderService_WebsocketSetURL_FullMethodName                   = "/gctrpc.GoCryptoTraderService/WebsocketSetURL"
	GoCryptoTraderService_GetRecentTrades_FullMethodName                   = "/gctrpc.GoCryptoTraderService/GetRecentTrades"
	GoCryptoTraderService_GetHistoricTrades_FullMethodName                 = "/gctrpc.GoCryptoTraderService/GetHistoricTrades"
	GoCryptoTraderService_GetSavedTrades_FullMethodName                    = "/gctrpc.GoCryptoTraderService/GetSavedTrades"
	GoCryptoTraderService_ConvertTradesToCandles_FullMethodName            = "/gctrpc.GoCryptoTraderService/ConvertTradesToCandles"
	GoCryptoTraderService_FindMissingSavedCandleIntervals_FullMethodName   = "/gctrpc.GoCryptoTraderService/FindMissingSavedCandleIntervals"
	GoCryptoTraderService_FindMissingSavedTradeIntervals_FullMethodName    = "/gctrpc.GoCryptoTraderService/FindMissingSavedTradeIntervals"
	GoCryptoTraderService_SetExchangeTradeProcessing_FullMethodName        = "/gctrpc.GoCryptoTraderService/SetExchangeTradeProcessing"
	GoCryptoTraderService_UpsertDataHistoryJob_FullMethodName              = "/gctrpc.GoCryptoTraderService/UpsertDataHistoryJob"
	GoCryptoTraderService_GetDataHistoryJobDetails_FullMethodName          = "/gctrpc.GoCryptoTraderService/GetDataHistoryJobDetails"
	GoCryptoTraderService_GetActiveDataHistoryJobs_FullMethodName          = "/gctrpc.GoCryptoTraderService/GetActiveDataHistoryJobs"
	GoCryptoTraderService_GetDataHistoryJobsBetween_FullMethodName         = "/gctrpc.GoCryptoTraderService/GetDataHistoryJobsBetween"
	GoCryptoTraderService_GetDataHistoryJobSummary_FullMethodName          = "/gctrpc.GoCryptoTraderService/GetDataHistoryJobSummary"
	GoCryptoTraderService_SetDataHistoryJobStatus_FullMethodName           = "/gctrpc.GoCryptoTraderService/SetDataHistoryJobStatus"
	GoCryptoTraderService_UpdateDataHistoryJobPrerequisite_FullMethodName  = "/gctrpc.GoCryptoTraderService/UpdateDataHistoryJobPrerequisite"
	GoCryptoTraderService_GetManagedOrders_FullMethodName                  = "/gctrpc.GoCryptoTraderService/GetManagedOrders"
	GoCryptoTraderService_ModifyOrder_FullMethodName                       = "/gctrpc.GoCryptoTraderService/ModifyOrder"
	GoCryptoTraderService_CurrencyStateGetAll_FullMethodName               = "/gctrpc.GoCryptoTraderService/CurrencyStateGetAll"
	GoCryptoTraderService_CurrencyStateTrading_FullMethodName              = "/gctrpc.GoCryptoTraderService/CurrencyStateTrading"
	GoCryptoTraderService_CurrencyStateDeposit_FullMethodName              = "/gctrpc.GoCryptoTraderService/CurrencyStateDeposit"
	GoCryptoTraderService_CurrencyStateWithdraw_FullMethodName             = "/gctrpc.GoCryptoTraderService/CurrencyStateWithdraw"
	GoCryptoTraderService_CurrencyStateTradingPair_FullMethodName          = "/gctrpc.GoCryptoTraderService/CurrencyStateTradingPair"
	GoCryptoTraderService_GetFuturesPositions_FullMethodName               = "/gctrpc.GoCryptoTraderService/GetFuturesPositions"
	GoCryptoTraderService_GetCollateral_FullMethodName                     = "/gctrpc.GoCryptoTraderService/GetCollateral"
	GoCryptoTraderService_Shutdown_FullMethodName                          = "/gctrpc.GoCryptoTraderService/Shutdown"
	GoCryptoTraderService_GetTechnicalAnalysis_FullMethodName              = "/gctrpc.GoCryptoTraderService/GetTechnicalAnalysis"
	GoCryptoTraderService_GetMarginRatesHistory_FullMethodName             = "/gctrpc.GoCryptoTraderService/GetMarginRatesHistory"
	GoCryptoTraderService_GetManagedPosition_FullMethodName                = "/gctrpc.GoCryptoTraderService/GetManagedPosition"
	GoCryptoTraderService_GetAllManagedPositions_FullMethodName            = "/gctrpc.GoCryptoTraderService/GetAllManagedPositions"
	GoCryptoTraderService_GetFundingRates_FullMethodName                   = "/gctrpc.GoCryptoTraderService/GetFundingRates"
	GoCryptoTraderService_GetLatestFundingRate_FullMethodName              = "/gctrpc.GoCryptoTraderService/GetLatestFundingRate"
	GoCryptoTraderService_GetOrderbookMovement_FullMethodName              = "/gctrpc.GoCryptoTraderService/GetOrderbookMovement"
	GoCryptoTraderService_GetOrderbookAmountByNominal_FullMethodName       = "/gctrpc.GoCryptoTraderService/GetOrderbookAmountByNominal"
	GoCryptoTraderService_GetOrderbookAmountByImpact_FullMethodName        = "/gctrpc.GoCryptoTraderService/GetOrderbookAmountByImpact"
)

// GoCryptoTraderServiceClient is the client API for GoCryptoTraderService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type GoCryptoTraderServiceClient interface {
	GetInfo(ctx context.Context, in *GetInfoRequest, opts ...grpc.CallOption) (*GetInfoResponse, error)
	GetSubsystems(ctx context.Context, in *GetSubsystemsRequest, opts ...grpc.CallOption) (*GetSusbsytemsResponse, error)
	EnableSubsystem(ctx context.Context, in *GenericSubsystemRequest, opts ...grpc.CallOption) (*GenericResponse, error)
	DisableSubsystem(ctx context.Context, in *GenericSubsystemRequest, opts ...grpc.CallOption) (*GenericResponse, error)
	GetRPCEndpoints(ctx context.Context, in *GetRPCEndpointsRequest, opts ...grpc.CallOption) (*GetRPCEndpointsResponse, error)
	GetCommunicationRelayers(ctx context.Context, in *GetCommunicationRelayersRequest, opts ...grpc.CallOption) (*GetCommunicationRelayersResponse, error)
	GetExchanges(ctx context.Context, in *GetExchangesRequest, opts ...grpc.CallOption) (*GetExchangesResponse, error)
	DisableExchange(ctx context.Context, in *GenericExchangeNameRequest, opts ...grpc.CallOption) (*GenericResponse, error)
	GetExchangeInfo(ctx context.Context, in *GenericExchangeNameRequest, opts ...grpc.CallOption) (*GetExchangeInfoResponse, error)
	GetExchangeOTPCode(ctx context.Context, in *GenericExchangeNameRequest, opts ...grpc.CallOption) (*GetExchangeOTPResponse, error)
	GetExchangeOTPCodes(ctx context.Context, in *GetExchangeOTPsRequest, opts ...grpc.CallOption) (*GetExchangeOTPsResponse, error)
	EnableExchange(ctx context.Context, in *GenericExchangeNameRequest, opts ...grpc.CallOption) (*GenericResponse, error)
	GetTicker(ctx context.Context, in *GetTickerRequest, opts ...grpc.CallOption) (*TickerResponse, error)
	GetTickers(ctx context.Context, in *GetTickersRequest, opts ...grpc.CallOption) (*GetTickersResponse, error)
	GetOrderbook(ctx context.Context, in *GetOrderbookRequest, opts ...grpc.CallOption) (*OrderbookResponse, error)
	GetOrderbooks(ctx context.Context, in *GetOrderbooksRequest, opts ...grpc.CallOption) (*GetOrderbooksResponse, error)
	GetAccountInfo(ctx context.Context, in *GetAccountInfoRequest, opts ...grpc.CallOption) (*GetAccountInfoResponse, error)
	UpdateAccountInfo(ctx context.Context, in *GetAccountInfoRequest, opts ...grpc.CallOption) (*GetAccountInfoResponse, error)
	GetAccountInfoStream(ctx context.Context, in *GetAccountInfoRequest, opts ...grpc.CallOption) (GoCryptoTraderService_GetAccountInfoStreamClient, error)
	GetConfig(ctx context.Context, in *GetConfigRequest, opts ...grpc.CallOption) (*GetConfigResponse, error)
	GetPortfolio(ctx context.Context, in *GetPortfolioRequest, opts ...grpc.CallOption) (*GetPortfolioResponse, error)
	GetPortfolioSummary(ctx context.Context, in *GetPortfolioSummaryRequest, opts ...grpc.CallOption) (*GetPortfolioSummaryResponse, error)
	AddPortfolioAddress(ctx context.Context, in *AddPortfolioAddressRequest, opts ...grpc.CallOption) (*GenericResponse, error)
	RemovePortfolioAddress(ctx context.Context, in *RemovePortfolioAddressRequest, opts ...grpc.CallOption) (*GenericResponse, error)
	GetForexProviders(ctx context.Context, in *GetForexProvidersRequest, opts ...grpc.CallOption) (*GetForexProvidersResponse, error)
	GetForexRates(ctx context.Context, in *GetForexRatesRequest, opts ...grpc.CallOption) (*GetForexRatesResponse, error)
	GetOrders(ctx context.Context, in *GetOrdersRequest, opts ...grpc.CallOption) (*GetOrdersResponse, error)
	GetOrder(ctx context.Context, in *GetOrderRequest, opts ...grpc.CallOption) (*OrderDetails, error)
	SubmitOrder(ctx context.Context, in *SubmitOrderRequest, opts ...grpc.CallOption) (*SubmitOrderResponse, error)
	SimulateOrder(ctx context.Context, in *SimulateOrderRequest, opts ...grpc.CallOption) (*SimulateOrderResponse, error)
	WhaleBomb(ctx context.Context, in *WhaleBombRequest, opts ...grpc.CallOption) (*SimulateOrderResponse, error)
	CancelOrder(ctx context.Context, in *CancelOrderRequest, opts ...grpc.CallOption) (*GenericResponse, error)
	CancelBatchOrders(ctx context.Context, in *CancelBatchOrdersRequest, opts ...grpc.CallOption) (*CancelBatchOrdersResponse, error)
	CancelAllOrders(ctx context.Context, in *CancelAllOrdersRequest, opts ...grpc.CallOption) (*CancelAllOrdersResponse, error)
	GetEvents(ctx context.Context, in *GetEventsRequest, opts ...grpc.CallOption) (*GetEventsResponse, error)
	AddEvent(ctx context.Context, in *AddEventRequest, opts ...grpc.CallOption) (*AddEventResponse, error)
	RemoveEvent(ctx context.Context, in *RemoveEventRequest, opts ...grpc.CallOption) (*GenericResponse, error)
	GetCryptocurrencyDepositAddresses(ctx context.Context, in *GetCryptocurrencyDepositAddressesRequest, opts ...grpc.CallOption) (*GetCryptocurrencyDepositAddressesResponse, error)
	GetCryptocurrencyDepositAddress(ctx context.Context, in *GetCryptocurrencyDepositAddressRequest, opts ...grpc.CallOption) (*GetCryptocurrencyDepositAddressResponse, error)
	GetAvailableTransferChains(ctx context.Context, in *GetAvailableTransferChainsRequest, opts ...grpc.CallOption) (*GetAvailableTransferChainsResponse, error)
	WithdrawFiatFunds(ctx context.Context, in *WithdrawFiatRequest, opts ...grpc.CallOption) (*WithdrawResponse, error)
	WithdrawCryptocurrencyFunds(ctx context.Context, in *WithdrawCryptoRequest, opts ...grpc.CallOption) (*WithdrawResponse, error)
	WithdrawalEventByID(ctx context.Context, in *WithdrawalEventByIDRequest, opts ...grpc.CallOption) (*WithdrawalEventByIDResponse, error)
	WithdrawalEventsByExchange(ctx context.Context, in *WithdrawalEventsByExchangeRequest, opts ...grpc.CallOption) (*WithdrawalEventsByExchangeResponse, error)
	WithdrawalEventsByDate(ctx context.Context, in *WithdrawalEventsByDateRequest, opts ...grpc.CallOption) (*WithdrawalEventsByExchangeResponse, error)
	GetLoggerDetails(ctx context.Context, in *GetLoggerDetailsRequest, opts ...grpc.CallOption) (*GetLoggerDetailsResponse, error)
	SetLoggerDetails(ctx context.Context, in *SetLoggerDetailsRequest, opts ...grpc.CallOption) (*GetLoggerDetailsResponse, error)
	GetExchangePairs(ctx context.Context, in *GetExchangePairsRequest, opts ...grpc.CallOption) (*GetExchangePairsResponse, error)
	SetExchangePair(ctx context.Context, in *SetExchangePairRequest, opts ...grpc.CallOption) (*GenericResponse, error)
	GetOrderbookStream(ctx context.Context, in *GetOrderbookStreamRequest, opts ...grpc.CallOption) (GoCryptoTraderService_GetOrderbookStreamClient, error)
	GetExchangeOrderbookStream(ctx context.Context, in *GetExchangeOrderbookStreamRequest, opts ...grpc.CallOption) (GoCryptoTraderService_GetExchangeOrderbookStreamClient, error)
	GetTickerStream(ctx context.Context, in *GetTickerStreamRequest, opts ...grpc.CallOption) (GoCryptoTraderService_GetTickerStreamClient, error)
	GetExchangeTickerStream(ctx context.Context, in *GetExchangeTickerStreamRequest, opts ...grpc.CallOption) (GoCryptoTraderService_GetExchangeTickerStreamClient, error)
	GetAuditEvent(ctx context.Context, in *GetAuditEventRequest, opts ...grpc.CallOption) (*GetAuditEventResponse, error)
	GCTScriptExecute(ctx context.Context, in *GCTScriptExecuteRequest, opts ...grpc.CallOption) (*GenericResponse, error)
	GCTScriptUpload(ctx context.Context, in *GCTScriptUploadRequest, opts ...grpc.CallOption) (*GenericResponse, error)
	GCTScriptReadScript(ctx context.Context, in *GCTScriptReadScriptRequest, opts ...grpc.CallOption) (*GCTScriptQueryResponse, error)
	GCTScriptStatus(ctx context.Context, in *GCTScriptStatusRequest, opts ...grpc.CallOption) (*GCTScriptStatusResponse, error)
	GCTScriptQuery(ctx context.Context, in *GCTScriptQueryRequest, opts ...grpc.CallOption) (*GCTScriptQueryResponse, error)
	GCTScriptStop(ctx context.Context, in *GCTScriptStopRequest, opts ...grpc.CallOption) (*GenericResponse, error)
	GCTScriptStopAll(ctx context.Context, in *GCTScriptStopAllRequest, opts ...grpc.CallOption) (*GenericResponse, error)
	GCTScriptListAll(ctx context.Context, in *GCTScriptListAllRequest, opts ...grpc.CallOption) (*GCTScriptStatusResponse, error)
	GCTScriptAutoLoadToggle(ctx context.Context, in *GCTScriptAutoLoadRequest, opts ...grpc.CallOption) (*GenericResponse, error)
	GetHistoricCandles(ctx context.Context, in *GetHistoricCandlesRequest, opts ...grpc.CallOption) (*GetHistoricCandlesResponse, error)
	SetExchangeAsset(ctx context.Context, in *SetExchangeAssetRequest, opts ...grpc.CallOption) (*GenericResponse, error)
	SetAllExchangePairs(ctx context.Context, in *SetExchangeAllPairsRequest, opts ...grpc.CallOption) (*GenericResponse, error)
	UpdateExchangeSupportedPairs(ctx context.Context, in *UpdateExchangeSupportedPairsRequest, opts ...grpc.CallOption) (*GenericResponse, error)
	GetExchangeAssets(ctx context.Context, in *GetExchangeAssetsRequest, opts ...grpc.CallOption) (*GetExchangeAssetsResponse, error)
	WebsocketGetInfo(ctx context.Context, in *WebsocketGetInfoRequest, opts ...grpc.CallOption) (*WebsocketGetInfoResponse, error)
	WebsocketSetEnabled(ctx context.Context, in *WebsocketSetEnabledRequest, opts ...grpc.CallOption) (*GenericResponse, error)
	WebsocketGetSubscriptions(ctx context.Context, in *WebsocketGetSubscriptionsRequest, opts ...grpc.CallOption) (*WebsocketGetSubscriptionsResponse, error)
	WebsocketSetProxy(ctx context.Context, in *WebsocketSetProxyRequest, opts ...grpc.CallOption) (*GenericResponse, error)
	WebsocketSetURL(ctx context.Context, in *WebsocketSetURLRequest, opts ...grpc.CallOption) (*GenericResponse, error)
	GetRecentTrades(ctx context.Context, in *GetSavedTradesRequest, opts ...grpc.CallOption) (*SavedTradesResponse, error)
	GetHistoricTrades(ctx context.Context, in *GetSavedTradesRequest, opts ...grpc.CallOption) (GoCryptoTraderService_GetHistoricTradesClient, error)
	GetSavedTrades(ctx context.Context, in *GetSavedTradesRequest, opts ...grpc.CallOption) (*SavedTradesResponse, error)
	ConvertTradesToCandles(ctx context.Context, in *ConvertTradesToCandlesRequest, opts ...grpc.CallOption) (*GetHistoricCandlesResponse, error)
	FindMissingSavedCandleIntervals(ctx context.Context, in *FindMissingCandlePeriodsRequest, opts ...grpc.CallOption) (*FindMissingIntervalsResponse, error)
	FindMissingSavedTradeIntervals(ctx context.Context, in *FindMissingTradePeriodsRequest, opts ...grpc.CallOption) (*FindMissingIntervalsResponse, error)
	SetExchangeTradeProcessing(ctx context.Context, in *SetExchangeTradeProcessingRequest, opts ...grpc.CallOption) (*GenericResponse, error)
	UpsertDataHistoryJob(ctx context.Context, in *UpsertDataHistoryJobRequest, opts ...grpc.CallOption) (*UpsertDataHistoryJobResponse, error)
	GetDataHistoryJobDetails(ctx context.Context, in *GetDataHistoryJobDetailsRequest, opts ...grpc.CallOption) (*DataHistoryJob, error)
	GetActiveDataHistoryJobs(ctx context.Context, in *GetInfoRequest, opts ...grpc.CallOption) (*DataHistoryJobs, error)
	GetDataHistoryJobsBetween(ctx context.Context, in *GetDataHistoryJobsBetweenRequest, opts ...grpc.CallOption) (*DataHistoryJobs, error)
	GetDataHistoryJobSummary(ctx context.Context, in *GetDataHistoryJobDetailsRequest, opts ...grpc.CallOption) (*DataHistoryJob, error)
	SetDataHistoryJobStatus(ctx context.Context, in *SetDataHistoryJobStatusRequest, opts ...grpc.CallOption) (*GenericResponse, error)
	UpdateDataHistoryJobPrerequisite(ctx context.Context, in *UpdateDataHistoryJobPrerequisiteRequest, opts ...grpc.CallOption) (*GenericResponse, error)
	GetManagedOrders(ctx context.Context, in *GetOrdersRequest, opts ...grpc.CallOption) (*GetOrdersResponse, error)
	ModifyOrder(ctx context.Context, in *ModifyOrderRequest, opts ...grpc.CallOption) (*ModifyOrderResponse, error)
	CurrencyStateGetAll(ctx context.Context, in *CurrencyStateGetAllRequest, opts ...grpc.CallOption) (*CurrencyStateResponse, error)
	CurrencyStateTrading(ctx context.Context, in *CurrencyStateTradingRequest, opts ...grpc.CallOption) (*GenericResponse, error)
	CurrencyStateDeposit(ctx context.Context, in *CurrencyStateDepositRequest, opts ...grpc.CallOption) (*GenericResponse, error)
	CurrencyStateWithdraw(ctx context.Context, in *CurrencyStateWithdrawRequest, opts ...grpc.CallOption) (*GenericResponse, error)
	CurrencyStateTradingPair(ctx context.Context, in *CurrencyStateTradingPairRequest, opts ...grpc.CallOption) (*GenericResponse, error)
	GetFuturesPositions(ctx context.Context, in *GetFuturesPositionsRequest, opts ...grpc.CallOption) (*GetFuturesPositionsResponse, error)
	GetCollateral(ctx context.Context, in *GetCollateralRequest, opts ...grpc.CallOption) (*GetCollateralResponse, error)
	Shutdown(ctx context.Context, in *ShutdownRequest, opts ...grpc.CallOption) (*ShutdownResponse, error)
	GetTechnicalAnalysis(ctx context.Context, in *GetTechnicalAnalysisRequest, opts ...grpc.CallOption) (*GetTechnicalAnalysisResponse, error)
	GetMarginRatesHistory(ctx context.Context, in *GetMarginRatesHistoryRequest, opts ...grpc.CallOption) (*GetMarginRatesHistoryResponse, error)
	GetManagedPosition(ctx context.Context, in *GetManagedPositionRequest, opts ...grpc.CallOption) (*GetManagedPositionsResponse, error)
	GetAllManagedPositions(ctx context.Context, in *GetAllManagedPositionsRequest, opts ...grpc.CallOption) (*GetManagedPositionsResponse, error)
	GetFundingRates(ctx context.Context, in *GetFundingRatesRequest, opts ...grpc.CallOption) (*GetFundingRatesResponse, error)
	GetLatestFundingRate(ctx context.Context, in *GetLatestFundingRateRequest, opts ...grpc.CallOption) (*GetLatestFundingRateResponse, error)
	GetOrderbookMovement(ctx context.Context, in *GetOrderbookMovementRequest, opts ...grpc.CallOption) (*GetOrderbookMovementResponse, error)
	GetOrderbookAmountByNominal(ctx context.Context, in *GetOrderbookAmountByNominalRequest, opts ...grpc.CallOption) (*GetOrderbookAmountByNominalResponse, error)
	GetOrderbookAmountByImpact(ctx context.Context, in *GetOrderbookAmountByImpactRequest, opts ...grpc.CallOption) (*GetOrderbookAmountByImpactResponse, error)
}

type goCryptoTraderServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewGoCryptoTraderServiceClient(cc grpc.ClientConnInterface) GoCryptoTraderServiceClient {
	return &goCryptoTraderServiceClient{cc}
}

func (c *goCryptoTraderServiceClient) GetInfo(ctx context.Context, in *GetInfoRequest, opts ...grpc.CallOption) (*GetInfoResponse, error) {
	out := new(GetInfoResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_GetInfo_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) GetSubsystems(ctx context.Context, in *GetSubsystemsRequest, opts ...grpc.CallOption) (*GetSusbsytemsResponse, error) {
	out := new(GetSusbsytemsResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_GetSubsystems_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) EnableSubsystem(ctx context.Context, in *GenericSubsystemRequest, opts ...grpc.CallOption) (*GenericResponse, error) {
	out := new(GenericResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_EnableSubsystem_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) DisableSubsystem(ctx context.Context, in *GenericSubsystemRequest, opts ...grpc.CallOption) (*GenericResponse, error) {
	out := new(GenericResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_DisableSubsystem_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) GetRPCEndpoints(ctx context.Context, in *GetRPCEndpointsRequest, opts ...grpc.CallOption) (*GetRPCEndpointsResponse, error) {
	out := new(GetRPCEndpointsResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_GetRPCEndpoints_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) GetCommunicationRelayers(ctx context.Context, in *GetCommunicationRelayersRequest, opts ...grpc.CallOption) (*GetCommunicationRelayersResponse, error) {
	out := new(GetCommunicationRelayersResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_GetCommunicationRelayers_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) GetExchanges(ctx context.Context, in *GetExchangesRequest, opts ...grpc.CallOption) (*GetExchangesResponse, error) {
	out := new(GetExchangesResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_GetExchanges_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) DisableExchange(ctx context.Context, in *GenericExchangeNameRequest, opts ...grpc.CallOption) (*GenericResponse, error) {
	out := new(GenericResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_DisableExchange_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) GetExchangeInfo(ctx context.Context, in *GenericExchangeNameRequest, opts ...grpc.CallOption) (*GetExchangeInfoResponse, error) {
	out := new(GetExchangeInfoResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_GetExchangeInfo_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) GetExchangeOTPCode(ctx context.Context, in *GenericExchangeNameRequest, opts ...grpc.CallOption) (*GetExchangeOTPResponse, error) {
	out := new(GetExchangeOTPResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_GetExchangeOTPCode_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) GetExchangeOTPCodes(ctx context.Context, in *GetExchangeOTPsRequest, opts ...grpc.CallOption) (*GetExchangeOTPsResponse, error) {
	out := new(GetExchangeOTPsResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_GetExchangeOTPCodes_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) EnableExchange(ctx context.Context, in *GenericExchangeNameRequest, opts ...grpc.CallOption) (*GenericResponse, error) {
	out := new(GenericResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_EnableExchange_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) GetTicker(ctx context.Context, in *GetTickerRequest, opts ...grpc.CallOption) (*TickerResponse, error) {
	out := new(TickerResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_GetTicker_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) GetTickers(ctx context.Context, in *GetTickersRequest, opts ...grpc.CallOption) (*GetTickersResponse, error) {
	out := new(GetTickersResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_GetTickers_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) GetOrderbook(ctx context.Context, in *GetOrderbookRequest, opts ...grpc.CallOption) (*OrderbookResponse, error) {
	out := new(OrderbookResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_GetOrderbook_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) GetOrderbooks(ctx context.Context, in *GetOrderbooksRequest, opts ...grpc.CallOption) (*GetOrderbooksResponse, error) {
	out := new(GetOrderbooksResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_GetOrderbooks_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) GetAccountInfo(ctx context.Context, in *GetAccountInfoRequest, opts ...grpc.CallOption) (*GetAccountInfoResponse, error) {
	out := new(GetAccountInfoResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_GetAccountInfo_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) UpdateAccountInfo(ctx context.Context, in *GetAccountInfoRequest, opts ...grpc.CallOption) (*GetAccountInfoResponse, error) {
	out := new(GetAccountInfoResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_UpdateAccountInfo_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) GetAccountInfoStream(ctx context.Context, in *GetAccountInfoRequest, opts ...grpc.CallOption) (GoCryptoTraderService_GetAccountInfoStreamClient, error) {
	stream, err := c.cc.NewStream(ctx, &GoCryptoTraderService_ServiceDesc.Streams[0], GoCryptoTraderService_GetAccountInfoStream_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &goCryptoTraderServiceGetAccountInfoStreamClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type GoCryptoTraderService_GetAccountInfoStreamClient interface {
	Recv() (*GetAccountInfoResponse, error)
	grpc.ClientStream
}

type goCryptoTraderServiceGetAccountInfoStreamClient struct {
	grpc.ClientStream
}

func (x *goCryptoTraderServiceGetAccountInfoStreamClient) Recv() (*GetAccountInfoResponse, error) {
	m := new(GetAccountInfoResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *goCryptoTraderServiceClient) GetConfig(ctx context.Context, in *GetConfigRequest, opts ...grpc.CallOption) (*GetConfigResponse, error) {
	out := new(GetConfigResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_GetConfig_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) GetPortfolio(ctx context.Context, in *GetPortfolioRequest, opts ...grpc.CallOption) (*GetPortfolioResponse, error) {
	out := new(GetPortfolioResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_GetPortfolio_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) GetPortfolioSummary(ctx context.Context, in *GetPortfolioSummaryRequest, opts ...grpc.CallOption) (*GetPortfolioSummaryResponse, error) {
	out := new(GetPortfolioSummaryResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_GetPortfolioSummary_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) AddPortfolioAddress(ctx context.Context, in *AddPortfolioAddressRequest, opts ...grpc.CallOption) (*GenericResponse, error) {
	out := new(GenericResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_AddPortfolioAddress_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) RemovePortfolioAddress(ctx context.Context, in *RemovePortfolioAddressRequest, opts ...grpc.CallOption) (*GenericResponse, error) {
	out := new(GenericResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_RemovePortfolioAddress_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) GetForexProviders(ctx context.Context, in *GetForexProvidersRequest, opts ...grpc.CallOption) (*GetForexProvidersResponse, error) {
	out := new(GetForexProvidersResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_GetForexProviders_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) GetForexRates(ctx context.Context, in *GetForexRatesRequest, opts ...grpc.CallOption) (*GetForexRatesResponse, error) {
	out := new(GetForexRatesResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_GetForexRates_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) GetOrders(ctx context.Context, in *GetOrdersRequest, opts ...grpc.CallOption) (*GetOrdersResponse, error) {
	out := new(GetOrdersResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_GetOrders_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) GetOrder(ctx context.Context, in *GetOrderRequest, opts ...grpc.CallOption) (*OrderDetails, error) {
	out := new(OrderDetails)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_GetOrder_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) SubmitOrder(ctx context.Context, in *SubmitOrderRequest, opts ...grpc.CallOption) (*SubmitOrderResponse, error) {
	out := new(SubmitOrderResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_SubmitOrder_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) SimulateOrder(ctx context.Context, in *SimulateOrderRequest, opts ...grpc.CallOption) (*SimulateOrderResponse, error) {
	out := new(SimulateOrderResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_SimulateOrder_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) WhaleBomb(ctx context.Context, in *WhaleBombRequest, opts ...grpc.CallOption) (*SimulateOrderResponse, error) {
	out := new(SimulateOrderResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_WhaleBomb_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) CancelOrder(ctx context.Context, in *CancelOrderRequest, opts ...grpc.CallOption) (*GenericResponse, error) {
	out := new(GenericResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_CancelOrder_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) CancelBatchOrders(ctx context.Context, in *CancelBatchOrdersRequest, opts ...grpc.CallOption) (*CancelBatchOrdersResponse, error) {
	out := new(CancelBatchOrdersResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_CancelBatchOrders_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) CancelAllOrders(ctx context.Context, in *CancelAllOrdersRequest, opts ...grpc.CallOption) (*CancelAllOrdersResponse, error) {
	out := new(CancelAllOrdersResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_CancelAllOrders_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) GetEvents(ctx context.Context, in *GetEventsRequest, opts ...grpc.CallOption) (*GetEventsResponse, error) {
	out := new(GetEventsResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_GetEvents_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) AddEvent(ctx context.Context, in *AddEventRequest, opts ...grpc.CallOption) (*AddEventResponse, error) {
	out := new(AddEventResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_AddEvent_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) RemoveEvent(ctx context.Context, in *RemoveEventRequest, opts ...grpc.CallOption) (*GenericResponse, error) {
	out := new(GenericResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_RemoveEvent_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) GetCryptocurrencyDepositAddresses(ctx context.Context, in *GetCryptocurrencyDepositAddressesRequest, opts ...grpc.CallOption) (*GetCryptocurrencyDepositAddressesResponse, error) {
	out := new(GetCryptocurrencyDepositAddressesResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_GetCryptocurrencyDepositAddresses_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) GetCryptocurrencyDepositAddress(ctx context.Context, in *GetCryptocurrencyDepositAddressRequest, opts ...grpc.CallOption) (*GetCryptocurrencyDepositAddressResponse, error) {
	out := new(GetCryptocurrencyDepositAddressResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_GetCryptocurrencyDepositAddress_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) GetAvailableTransferChains(ctx context.Context, in *GetAvailableTransferChainsRequest, opts ...grpc.CallOption) (*GetAvailableTransferChainsResponse, error) {
	out := new(GetAvailableTransferChainsResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_GetAvailableTransferChains_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) WithdrawFiatFunds(ctx context.Context, in *WithdrawFiatRequest, opts ...grpc.CallOption) (*WithdrawResponse, error) {
	out := new(WithdrawResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_WithdrawFiatFunds_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) WithdrawCryptocurrencyFunds(ctx context.Context, in *WithdrawCryptoRequest, opts ...grpc.CallOption) (*WithdrawResponse, error) {
	out := new(WithdrawResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_WithdrawCryptocurrencyFunds_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) WithdrawalEventByID(ctx context.Context, in *WithdrawalEventByIDRequest, opts ...grpc.CallOption) (*WithdrawalEventByIDResponse, error) {
	out := new(WithdrawalEventByIDResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_WithdrawalEventByID_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) WithdrawalEventsByExchange(ctx context.Context, in *WithdrawalEventsByExchangeRequest, opts ...grpc.CallOption) (*WithdrawalEventsByExchangeResponse, error) {
	out := new(WithdrawalEventsByExchangeResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_WithdrawalEventsByExchange_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) WithdrawalEventsByDate(ctx context.Context, in *WithdrawalEventsByDateRequest, opts ...grpc.CallOption) (*WithdrawalEventsByExchangeResponse, error) {
	out := new(WithdrawalEventsByExchangeResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_WithdrawalEventsByDate_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) GetLoggerDetails(ctx context.Context, in *GetLoggerDetailsRequest, opts ...grpc.CallOption) (*GetLoggerDetailsResponse, error) {
	out := new(GetLoggerDetailsResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_GetLoggerDetails_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) SetLoggerDetails(ctx context.Context, in *SetLoggerDetailsRequest, opts ...grpc.CallOption) (*GetLoggerDetailsResponse, error) {
	out := new(GetLoggerDetailsResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_SetLoggerDetails_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) GetExchangePairs(ctx context.Context, in *GetExchangePairsRequest, opts ...grpc.CallOption) (*GetExchangePairsResponse, error) {
	out := new(GetExchangePairsResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_GetExchangePairs_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) SetExchangePair(ctx context.Context, in *SetExchangePairRequest, opts ...grpc.CallOption) (*GenericResponse, error) {
	out := new(GenericResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_SetExchangePair_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) GetOrderbookStream(ctx context.Context, in *GetOrderbookStreamRequest, opts ...grpc.CallOption) (GoCryptoTraderService_GetOrderbookStreamClient, error) {
	stream, err := c.cc.NewStream(ctx, &GoCryptoTraderService_ServiceDesc.Streams[1], GoCryptoTraderService_GetOrderbookStream_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &goCryptoTraderServiceGetOrderbookStreamClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type GoCryptoTraderService_GetOrderbookStreamClient interface {
	Recv() (*OrderbookResponse, error)
	grpc.ClientStream
}

type goCryptoTraderServiceGetOrderbookStreamClient struct {
	grpc.ClientStream
}

func (x *goCryptoTraderServiceGetOrderbookStreamClient) Recv() (*OrderbookResponse, error) {
	m := new(OrderbookResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *goCryptoTraderServiceClient) GetExchangeOrderbookStream(ctx context.Context, in *GetExchangeOrderbookStreamRequest, opts ...grpc.CallOption) (GoCryptoTraderService_GetExchangeOrderbookStreamClient, error) {
	stream, err := c.cc.NewStream(ctx, &GoCryptoTraderService_ServiceDesc.Streams[2], GoCryptoTraderService_GetExchangeOrderbookStream_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &goCryptoTraderServiceGetExchangeOrderbookStreamClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type GoCryptoTraderService_GetExchangeOrderbookStreamClient interface {
	Recv() (*OrderbookResponse, error)
	grpc.ClientStream
}

type goCryptoTraderServiceGetExchangeOrderbookStreamClient struct {
	grpc.ClientStream
}

func (x *goCryptoTraderServiceGetExchangeOrderbookStreamClient) Recv() (*OrderbookResponse, error) {
	m := new(OrderbookResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *goCryptoTraderServiceClient) GetTickerStream(ctx context.Context, in *GetTickerStreamRequest, opts ...grpc.CallOption) (GoCryptoTraderService_GetTickerStreamClient, error) {
	stream, err := c.cc.NewStream(ctx, &GoCryptoTraderService_ServiceDesc.Streams[3], GoCryptoTraderService_GetTickerStream_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &goCryptoTraderServiceGetTickerStreamClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type GoCryptoTraderService_GetTickerStreamClient interface {
	Recv() (*TickerResponse, error)
	grpc.ClientStream
}

type goCryptoTraderServiceGetTickerStreamClient struct {
	grpc.ClientStream
}

func (x *goCryptoTraderServiceGetTickerStreamClient) Recv() (*TickerResponse, error) {
	m := new(TickerResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *goCryptoTraderServiceClient) GetExchangeTickerStream(ctx context.Context, in *GetExchangeTickerStreamRequest, opts ...grpc.CallOption) (GoCryptoTraderService_GetExchangeTickerStreamClient, error) {
	stream, err := c.cc.NewStream(ctx, &GoCryptoTraderService_ServiceDesc.Streams[4], GoCryptoTraderService_GetExchangeTickerStream_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &goCryptoTraderServiceGetExchangeTickerStreamClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type GoCryptoTraderService_GetExchangeTickerStreamClient interface {
	Recv() (*TickerResponse, error)
	grpc.ClientStream
}

type goCryptoTraderServiceGetExchangeTickerStreamClient struct {
	grpc.ClientStream
}

func (x *goCryptoTraderServiceGetExchangeTickerStreamClient) Recv() (*TickerResponse, error) {
	m := new(TickerResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *goCryptoTraderServiceClient) GetAuditEvent(ctx context.Context, in *GetAuditEventRequest, opts ...grpc.CallOption) (*GetAuditEventResponse, error) {
	out := new(GetAuditEventResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_GetAuditEvent_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) GCTScriptExecute(ctx context.Context, in *GCTScriptExecuteRequest, opts ...grpc.CallOption) (*GenericResponse, error) {
	out := new(GenericResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_GCTScriptExecute_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) GCTScriptUpload(ctx context.Context, in *GCTScriptUploadRequest, opts ...grpc.CallOption) (*GenericResponse, error) {
	out := new(GenericResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_GCTScriptUpload_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) GCTScriptReadScript(ctx context.Context, in *GCTScriptReadScriptRequest, opts ...grpc.CallOption) (*GCTScriptQueryResponse, error) {
	out := new(GCTScriptQueryResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_GCTScriptReadScript_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) GCTScriptStatus(ctx context.Context, in *GCTScriptStatusRequest, opts ...grpc.CallOption) (*GCTScriptStatusResponse, error) {
	out := new(GCTScriptStatusResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_GCTScriptStatus_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) GCTScriptQuery(ctx context.Context, in *GCTScriptQueryRequest, opts ...grpc.CallOption) (*GCTScriptQueryResponse, error) {
	out := new(GCTScriptQueryResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_GCTScriptQuery_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) GCTScriptStop(ctx context.Context, in *GCTScriptStopRequest, opts ...grpc.CallOption) (*GenericResponse, error) {
	out := new(GenericResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_GCTScriptStop_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) GCTScriptStopAll(ctx context.Context, in *GCTScriptStopAllRequest, opts ...grpc.CallOption) (*GenericResponse, error) {
	out := new(GenericResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_GCTScriptStopAll_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) GCTScriptListAll(ctx context.Context, in *GCTScriptListAllRequest, opts ...grpc.CallOption) (*GCTScriptStatusResponse, error) {
	out := new(GCTScriptStatusResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_GCTScriptListAll_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) GCTScriptAutoLoadToggle(ctx context.Context, in *GCTScriptAutoLoadRequest, opts ...grpc.CallOption) (*GenericResponse, error) {
	out := new(GenericResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_GCTScriptAutoLoadToggle_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) GetHistoricCandles(ctx context.Context, in *GetHistoricCandlesRequest, opts ...grpc.CallOption) (*GetHistoricCandlesResponse, error) {
	out := new(GetHistoricCandlesResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_GetHistoricCandles_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) SetExchangeAsset(ctx context.Context, in *SetExchangeAssetRequest, opts ...grpc.CallOption) (*GenericResponse, error) {
	out := new(GenericResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_SetExchangeAsset_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) SetAllExchangePairs(ctx context.Context, in *SetExchangeAllPairsRequest, opts ...grpc.CallOption) (*GenericResponse, error) {
	out := new(GenericResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_SetAllExchangePairs_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) UpdateExchangeSupportedPairs(ctx context.Context, in *UpdateExchangeSupportedPairsRequest, opts ...grpc.CallOption) (*GenericResponse, error) {
	out := new(GenericResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_UpdateExchangeSupportedPairs_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) GetExchangeAssets(ctx context.Context, in *GetExchangeAssetsRequest, opts ...grpc.CallOption) (*GetExchangeAssetsResponse, error) {
	out := new(GetExchangeAssetsResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_GetExchangeAssets_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) WebsocketGetInfo(ctx context.Context, in *WebsocketGetInfoRequest, opts ...grpc.CallOption) (*WebsocketGetInfoResponse, error) {
	out := new(WebsocketGetInfoResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_WebsocketGetInfo_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) WebsocketSetEnabled(ctx context.Context, in *WebsocketSetEnabledRequest, opts ...grpc.CallOption) (*GenericResponse, error) {
	out := new(GenericResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_WebsocketSetEnabled_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) WebsocketGetSubscriptions(ctx context.Context, in *WebsocketGetSubscriptionsRequest, opts ...grpc.CallOption) (*WebsocketGetSubscriptionsResponse, error) {
	out := new(WebsocketGetSubscriptionsResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_WebsocketGetSubscriptions_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) WebsocketSetProxy(ctx context.Context, in *WebsocketSetProxyRequest, opts ...grpc.CallOption) (*GenericResponse, error) {
	out := new(GenericResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_WebsocketSetProxy_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) WebsocketSetURL(ctx context.Context, in *WebsocketSetURLRequest, opts ...grpc.CallOption) (*GenericResponse, error) {
	out := new(GenericResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_WebsocketSetURL_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) GetRecentTrades(ctx context.Context, in *GetSavedTradesRequest, opts ...grpc.CallOption) (*SavedTradesResponse, error) {
	out := new(SavedTradesResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_GetRecentTrades_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) GetHistoricTrades(ctx context.Context, in *GetSavedTradesRequest, opts ...grpc.CallOption) (GoCryptoTraderService_GetHistoricTradesClient, error) {
	stream, err := c.cc.NewStream(ctx, &GoCryptoTraderService_ServiceDesc.Streams[5], GoCryptoTraderService_GetHistoricTrades_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &goCryptoTraderServiceGetHistoricTradesClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type GoCryptoTraderService_GetHistoricTradesClient interface {
	Recv() (*SavedTradesResponse, error)
	grpc.ClientStream
}

type goCryptoTraderServiceGetHistoricTradesClient struct {
	grpc.ClientStream
}

func (x *goCryptoTraderServiceGetHistoricTradesClient) Recv() (*SavedTradesResponse, error) {
	m := new(SavedTradesResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *goCryptoTraderServiceClient) GetSavedTrades(ctx context.Context, in *GetSavedTradesRequest, opts ...grpc.CallOption) (*SavedTradesResponse, error) {
	out := new(SavedTradesResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_GetSavedTrades_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) ConvertTradesToCandles(ctx context.Context, in *ConvertTradesToCandlesRequest, opts ...grpc.CallOption) (*GetHistoricCandlesResponse, error) {
	out := new(GetHistoricCandlesResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_ConvertTradesToCandles_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) FindMissingSavedCandleIntervals(ctx context.Context, in *FindMissingCandlePeriodsRequest, opts ...grpc.CallOption) (*FindMissingIntervalsResponse, error) {
	out := new(FindMissingIntervalsResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_FindMissingSavedCandleIntervals_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) FindMissingSavedTradeIntervals(ctx context.Context, in *FindMissingTradePeriodsRequest, opts ...grpc.CallOption) (*FindMissingIntervalsResponse, error) {
	out := new(FindMissingIntervalsResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_FindMissingSavedTradeIntervals_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) SetExchangeTradeProcessing(ctx context.Context, in *SetExchangeTradeProcessingRequest, opts ...grpc.CallOption) (*GenericResponse, error) {
	out := new(GenericResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_SetExchangeTradeProcessing_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) UpsertDataHistoryJob(ctx context.Context, in *UpsertDataHistoryJobRequest, opts ...grpc.CallOption) (*UpsertDataHistoryJobResponse, error) {
	out := new(UpsertDataHistoryJobResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_UpsertDataHistoryJob_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) GetDataHistoryJobDetails(ctx context.Context, in *GetDataHistoryJobDetailsRequest, opts ...grpc.CallOption) (*DataHistoryJob, error) {
	out := new(DataHistoryJob)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_GetDataHistoryJobDetails_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) GetActiveDataHistoryJobs(ctx context.Context, in *GetInfoRequest, opts ...grpc.CallOption) (*DataHistoryJobs, error) {
	out := new(DataHistoryJobs)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_GetActiveDataHistoryJobs_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) GetDataHistoryJobsBetween(ctx context.Context, in *GetDataHistoryJobsBetweenRequest, opts ...grpc.CallOption) (*DataHistoryJobs, error) {
	out := new(DataHistoryJobs)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_GetDataHistoryJobsBetween_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) GetDataHistoryJobSummary(ctx context.Context, in *GetDataHistoryJobDetailsRequest, opts ...grpc.CallOption) (*DataHistoryJob, error) {
	out := new(DataHistoryJob)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_GetDataHistoryJobSummary_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) SetDataHistoryJobStatus(ctx context.Context, in *SetDataHistoryJobStatusRequest, opts ...grpc.CallOption) (*GenericResponse, error) {
	out := new(GenericResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_SetDataHistoryJobStatus_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) UpdateDataHistoryJobPrerequisite(ctx context.Context, in *UpdateDataHistoryJobPrerequisiteRequest, opts ...grpc.CallOption) (*GenericResponse, error) {
	out := new(GenericResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_UpdateDataHistoryJobPrerequisite_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) GetManagedOrders(ctx context.Context, in *GetOrdersRequest, opts ...grpc.CallOption) (*GetOrdersResponse, error) {
	out := new(GetOrdersResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_GetManagedOrders_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) ModifyOrder(ctx context.Context, in *ModifyOrderRequest, opts ...grpc.CallOption) (*ModifyOrderResponse, error) {
	out := new(ModifyOrderResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_ModifyOrder_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) CurrencyStateGetAll(ctx context.Context, in *CurrencyStateGetAllRequest, opts ...grpc.CallOption) (*CurrencyStateResponse, error) {
	out := new(CurrencyStateResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_CurrencyStateGetAll_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) CurrencyStateTrading(ctx context.Context, in *CurrencyStateTradingRequest, opts ...grpc.CallOption) (*GenericResponse, error) {
	out := new(GenericResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_CurrencyStateTrading_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) CurrencyStateDeposit(ctx context.Context, in *CurrencyStateDepositRequest, opts ...grpc.CallOption) (*GenericResponse, error) {
	out := new(GenericResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_CurrencyStateDeposit_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) CurrencyStateWithdraw(ctx context.Context, in *CurrencyStateWithdrawRequest, opts ...grpc.CallOption) (*GenericResponse, error) {
	out := new(GenericResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_CurrencyStateWithdraw_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) CurrencyStateTradingPair(ctx context.Context, in *CurrencyStateTradingPairRequest, opts ...grpc.CallOption) (*GenericResponse, error) {
	out := new(GenericResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_CurrencyStateTradingPair_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) GetFuturesPositions(ctx context.Context, in *GetFuturesPositionsRequest, opts ...grpc.CallOption) (*GetFuturesPositionsResponse, error) {
	out := new(GetFuturesPositionsResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_GetFuturesPositions_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) GetCollateral(ctx context.Context, in *GetCollateralRequest, opts ...grpc.CallOption) (*GetCollateralResponse, error) {
	out := new(GetCollateralResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_GetCollateral_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) Shutdown(ctx context.Context, in *ShutdownRequest, opts ...grpc.CallOption) (*ShutdownResponse, error) {
	out := new(ShutdownResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_Shutdown_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) GetTechnicalAnalysis(ctx context.Context, in *GetTechnicalAnalysisRequest, opts ...grpc.CallOption) (*GetTechnicalAnalysisResponse, error) {
	out := new(GetTechnicalAnalysisResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_GetTechnicalAnalysis_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) GetMarginRatesHistory(ctx context.Context, in *GetMarginRatesHistoryRequest, opts ...grpc.CallOption) (*GetMarginRatesHistoryResponse, error) {
	out := new(GetMarginRatesHistoryResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_GetMarginRatesHistory_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) GetManagedPosition(ctx context.Context, in *GetManagedPositionRequest, opts ...grpc.CallOption) (*GetManagedPositionsResponse, error) {
	out := new(GetManagedPositionsResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_GetManagedPosition_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) GetAllManagedPositions(ctx context.Context, in *GetAllManagedPositionsRequest, opts ...grpc.CallOption) (*GetManagedPositionsResponse, error) {
	out := new(GetManagedPositionsResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_GetAllManagedPositions_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) GetFundingRates(ctx context.Context, in *GetFundingRatesRequest, opts ...grpc.CallOption) (*GetFundingRatesResponse, error) {
	out := new(GetFundingRatesResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_GetFundingRates_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) GetLatestFundingRate(ctx context.Context, in *GetLatestFundingRateRequest, opts ...grpc.CallOption) (*GetLatestFundingRateResponse, error) {
	out := new(GetLatestFundingRateResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_GetLatestFundingRate_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) GetOrderbookMovement(ctx context.Context, in *GetOrderbookMovementRequest, opts ...grpc.CallOption) (*GetOrderbookMovementResponse, error) {
	out := new(GetOrderbookMovementResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_GetOrderbookMovement_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) GetOrderbookAmountByNominal(ctx context.Context, in *GetOrderbookAmountByNominalRequest, opts ...grpc.CallOption) (*GetOrderbookAmountByNominalResponse, error) {
	out := new(GetOrderbookAmountByNominalResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_GetOrderbookAmountByNominal_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goCryptoTraderServiceClient) GetOrderbookAmountByImpact(ctx context.Context, in *GetOrderbookAmountByImpactRequest, opts ...grpc.CallOption) (*GetOrderbookAmountByImpactResponse, error) {
	out := new(GetOrderbookAmountByImpactResponse)
	err := c.cc.Invoke(ctx, GoCryptoTraderService_GetOrderbookAmountByImpact_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// GoCryptoTraderServiceServer is the server API for GoCryptoTraderService service.
// All implementations must embed UnimplementedGoCryptoTraderServiceServer
// for forward compatibility
type GoCryptoTraderServiceServer interface {
	GetInfo(context.Context, *GetInfoRequest) (*GetInfoResponse, error)
	GetSubsystems(context.Context, *GetSubsystemsRequest) (*GetSusbsytemsResponse, error)
	EnableSubsystem(context.Context, *GenericSubsystemRequest) (*GenericResponse, error)
	DisableSubsystem(context.Context, *GenericSubsystemRequest) (*GenericResponse, error)
	GetRPCEndpoints(context.Context, *GetRPCEndpointsRequest) (*GetRPCEndpointsResponse, error)
	GetCommunicationRelayers(context.Context, *GetCommunicationRelayersRequest) (*GetCommunicationRelayersResponse, error)
	GetExchanges(context.Context, *GetExchangesRequest) (*GetExchangesResponse, error)
	DisableExchange(context.Context, *GenericExchangeNameRequest) (*GenericResponse, error)
	GetExchangeInfo(context.Context, *GenericExchangeNameRequest) (*GetExchangeInfoResponse, error)
	GetExchangeOTPCode(context.Context, *GenericExchangeNameRequest) (*GetExchangeOTPResponse, error)
	GetExchangeOTPCodes(context.Context, *GetExchangeOTPsRequest) (*GetExchangeOTPsResponse, error)
	EnableExchange(context.Context, *GenericExchangeNameRequest) (*GenericResponse, error)
	GetTicker(context.Context, *GetTickerRequest) (*TickerResponse, error)
	GetTickers(context.Context, *GetTickersRequest) (*GetTickersResponse, error)
	GetOrderbook(context.Context, *GetOrderbookRequest) (*OrderbookResponse, error)
	GetOrderbooks(context.Context, *GetOrderbooksRequest) (*GetOrderbooksResponse, error)
	GetAccountInfo(context.Context, *GetAccountInfoRequest) (*GetAccountInfoResponse, error)
	UpdateAccountInfo(context.Context, *GetAccountInfoRequest) (*GetAccountInfoResponse, error)
	GetAccountInfoStream(*GetAccountInfoRequest, GoCryptoTraderService_GetAccountInfoStreamServer) error
	GetConfig(context.Context, *GetConfigRequest) (*GetConfigResponse, error)
	GetPortfolio(context.Context, *GetPortfolioRequest) (*GetPortfolioResponse, error)
	GetPortfolioSummary(context.Context, *GetPortfolioSummaryRequest) (*GetPortfolioSummaryResponse, error)
	AddPortfolioAddress(context.Context, *AddPortfolioAddressRequest) (*GenericResponse, error)
	RemovePortfolioAddress(context.Context, *RemovePortfolioAddressRequest) (*GenericResponse, error)
	GetForexProviders(context.Context, *GetForexProvidersRequest) (*GetForexProvidersResponse, error)
	GetForexRates(context.Context, *GetForexRatesRequest) (*GetForexRatesResponse, error)
	GetOrders(context.Context, *GetOrdersRequest) (*GetOrdersResponse, error)
	GetOrder(context.Context, *GetOrderRequest) (*OrderDetails, error)
	SubmitOrder(context.Context, *SubmitOrderRequest) (*SubmitOrderResponse, error)
	SimulateOrder(context.Context, *SimulateOrderRequest) (*SimulateOrderResponse, error)
	WhaleBomb(context.Context, *WhaleBombRequest) (*SimulateOrderResponse, error)
	CancelOrder(context.Context, *CancelOrderRequest) (*GenericResponse, error)
	CancelBatchOrders(context.Context, *CancelBatchOrdersRequest) (*CancelBatchOrdersResponse, error)
	CancelAllOrders(context.Context, *CancelAllOrdersRequest) (*CancelAllOrdersResponse, error)
	GetEvents(context.Context, *GetEventsRequest) (*GetEventsResponse, error)
	AddEvent(context.Context, *AddEventRequest) (*AddEventResponse, error)
	RemoveEvent(context.Context, *RemoveEventRequest) (*GenericResponse, error)
	GetCryptocurrencyDepositAddresses(context.Context, *GetCryptocurrencyDepositAddressesRequest) (*GetCryptocurrencyDepositAddressesResponse, error)
	GetCryptocurrencyDepositAddress(context.Context, *GetCryptocurrencyDepositAddressRequest) (*GetCryptocurrencyDepositAddressResponse, error)
	GetAvailableTransferChains(context.Context, *GetAvailableTransferChainsRequest) (*GetAvailableTransferChainsResponse, error)
	WithdrawFiatFunds(context.Context, *WithdrawFiatRequest) (*WithdrawResponse, error)
	WithdrawCryptocurrencyFunds(context.Context, *WithdrawCryptoRequest) (*WithdrawResponse, error)
	WithdrawalEventByID(context.Context, *WithdrawalEventByIDRequest) (*WithdrawalEventByIDResponse, error)
	WithdrawalEventsByExchange(context.Context, *WithdrawalEventsByExchangeRequest) (*WithdrawalEventsByExchangeResponse, error)
	WithdrawalEventsByDate(context.Context, *WithdrawalEventsByDateRequest) (*WithdrawalEventsByExchangeResponse, error)
	GetLoggerDetails(context.Context, *GetLoggerDetailsRequest) (*GetLoggerDetailsResponse, error)
	SetLoggerDetails(context.Context, *SetLoggerDetailsRequest) (*GetLoggerDetailsResponse, error)
	GetExchangePairs(context.Context, *GetExchangePairsRequest) (*GetExchangePairsResponse, error)
	SetExchangePair(context.Context, *SetExchangePairRequest) (*GenericResponse, error)
	GetOrderbookStream(*GetOrderbookStreamRequest, GoCryptoTraderService_GetOrderbookStreamServer) error
	GetExchangeOrderbookStream(*GetExchangeOrderbookStreamRequest, GoCryptoTraderService_GetExchangeOrderbookStreamServer) error
	GetTickerStream(*GetTickerStreamRequest, GoCryptoTraderService_GetTickerStreamServer) error
	GetExchangeTickerStream(*GetExchangeTickerStreamRequest, GoCryptoTraderService_GetExchangeTickerStreamServer) error
	GetAuditEvent(context.Context, *GetAuditEventRequest) (*GetAuditEventResponse, error)
	GCTScriptExecute(context.Context, *GCTScriptExecuteRequest) (*GenericResponse, error)
	GCTScriptUpload(context.Context, *GCTScriptUploadRequest) (*GenericResponse, error)
	GCTScriptReadScript(context.Context, *GCTScriptReadScriptRequest) (*GCTScriptQueryResponse, error)
	GCTScriptStatus(context.Context, *GCTScriptStatusRequest) (*GCTScriptStatusResponse, error)
	GCTScriptQuery(context.Context, *GCTScriptQueryRequest) (*GCTScriptQueryResponse, error)
	GCTScriptStop(context.Context, *GCTScriptStopRequest) (*GenericResponse, error)
	GCTScriptStopAll(context.Context, *GCTScriptStopAllRequest) (*GenericResponse, error)
	GCTScriptListAll(context.Context, *GCTScriptListAllRequest) (*GCTScriptStatusResponse, error)
	GCTScriptAutoLoadToggle(context.Context, *GCTScriptAutoLoadRequest) (*GenericResponse, error)
	GetHistoricCandles(context.Context, *GetHistoricCandlesRequest) (*GetHistoricCandlesResponse, error)
	SetExchangeAsset(context.Context, *SetExchangeAssetRequest) (*GenericResponse, error)
	SetAllExchangePairs(context.Context, *SetExchangeAllPairsRequest) (*GenericResponse, error)
	UpdateExchangeSupportedPairs(context.Context, *UpdateExchangeSupportedPairsRequest) (*GenericResponse, error)
	GetExchangeAssets(context.Context, *GetExchangeAssetsRequest) (*GetExchangeAssetsResponse, error)
	WebsocketGetInfo(context.Context, *WebsocketGetInfoRequest) (*WebsocketGetInfoResponse, error)
	WebsocketSetEnabled(context.Context, *WebsocketSetEnabledRequest) (*GenericResponse, error)
	WebsocketGetSubscriptions(context.Context, *WebsocketGetSubscriptionsRequest) (*WebsocketGetSubscriptionsResponse, error)
	WebsocketSetProxy(context.Context, *WebsocketSetProxyRequest) (*GenericResponse, error)
	WebsocketSetURL(context.Context, *WebsocketSetURLRequest) (*GenericResponse, error)
	GetRecentTrades(context.Context, *GetSavedTradesRequest) (*SavedTradesResponse, error)
	GetHistoricTrades(*GetSavedTradesRequest, GoCryptoTraderService_GetHistoricTradesServer) error
	GetSavedTrades(context.Context, *GetSavedTradesRequest) (*SavedTradesResponse, error)
	ConvertTradesToCandles(context.Context, *ConvertTradesToCandlesRequest) (*GetHistoricCandlesResponse, error)
	FindMissingSavedCandleIntervals(context.Context, *FindMissingCandlePeriodsRequest) (*FindMissingIntervalsResponse, error)
	FindMissingSavedTradeIntervals(context.Context, *FindMissingTradePeriodsRequest) (*FindMissingIntervalsResponse, error)
	SetExchangeTradeProcessing(context.Context, *SetExchangeTradeProcessingRequest) (*GenericResponse, error)
	UpsertDataHistoryJob(context.Context, *UpsertDataHistoryJobRequest) (*UpsertDataHistoryJobResponse, error)
	GetDataHistoryJobDetails(context.Context, *GetDataHistoryJobDetailsRequest) (*DataHistoryJob, error)
	GetActiveDataHistoryJobs(context.Context, *GetInfoRequest) (*DataHistoryJobs, error)
	GetDataHistoryJobsBetween(context.Context, *GetDataHistoryJobsBetweenRequest) (*DataHistoryJobs, error)
	GetDataHistoryJobSummary(context.Context, *GetDataHistoryJobDetailsRequest) (*DataHistoryJob, error)
	SetDataHistoryJobStatus(context.Context, *SetDataHistoryJobStatusRequest) (*GenericResponse, error)
	UpdateDataHistoryJobPrerequisite(context.Context, *UpdateDataHistoryJobPrerequisiteRequest) (*GenericResponse, error)
	GetManagedOrders(context.Context, *GetOrdersRequest) (*GetOrdersResponse, error)
	ModifyOrder(context.Context, *ModifyOrderRequest) (*ModifyOrderResponse, error)
	CurrencyStateGetAll(context.Context, *CurrencyStateGetAllRequest) (*CurrencyStateResponse, error)
	CurrencyStateTrading(context.Context, *CurrencyStateTradingRequest) (*GenericResponse, error)
	CurrencyStateDeposit(context.Context, *CurrencyStateDepositRequest) (*GenericResponse, error)
	CurrencyStateWithdraw(context.Context, *CurrencyStateWithdrawRequest) (*GenericResponse, error)
	CurrencyStateTradingPair(context.Context, *CurrencyStateTradingPairRequest) (*GenericResponse, error)
	GetFuturesPositions(context.Context, *GetFuturesPositionsRequest) (*GetFuturesPositionsResponse, error)
	GetCollateral(context.Context, *GetCollateralRequest) (*GetCollateralResponse, error)
	Shutdown(context.Context, *ShutdownRequest) (*ShutdownResponse, error)
	GetTechnicalAnalysis(context.Context, *GetTechnicalAnalysisRequest) (*GetTechnicalAnalysisResponse, error)
	GetMarginRatesHistory(context.Context, *GetMarginRatesHistoryRequest) (*GetMarginRatesHistoryResponse, error)
	GetManagedPosition(context.Context, *GetManagedPositionRequest) (*GetManagedPositionsResponse, error)
	GetAllManagedPositions(context.Context, *GetAllManagedPositionsRequest) (*GetManagedPositionsResponse, error)
	GetFundingRates(context.Context, *GetFundingRatesRequest) (*GetFundingRatesResponse, error)
	GetLatestFundingRate(context.Context, *GetLatestFundingRateRequest) (*GetLatestFundingRateResponse, error)
	GetOrderbookMovement(context.Context, *GetOrderbookMovementRequest) (*GetOrderbookMovementResponse, error)
	GetOrderbookAmountByNominal(context.Context, *GetOrderbookAmountByNominalRequest) (*GetOrderbookAmountByNominalResponse, error)
	GetOrderbookAmountByImpact(context.Context, *GetOrderbookAmountByImpactRequest) (*GetOrderbookAmountByImpactResponse, error)
	mustEmbedUnimplementedGoCryptoTraderServiceServer()
}

// UnimplementedGoCryptoTraderServiceServer must be embedded to have forward compatible implementations.
type UnimplementedGoCryptoTraderServiceServer struct {
}

func (UnimplementedGoCryptoTraderServiceServer) GetInfo(context.Context, *GetInfoRequest) (*GetInfoResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetInfo not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GetSubsystems(context.Context, *GetSubsystemsRequest) (*GetSusbsytemsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetSubsystems not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) EnableSubsystem(context.Context, *GenericSubsystemRequest) (*GenericResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method EnableSubsystem not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) DisableSubsystem(context.Context, *GenericSubsystemRequest) (*GenericResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DisableSubsystem not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GetRPCEndpoints(context.Context, *GetRPCEndpointsRequest) (*GetRPCEndpointsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetRPCEndpoints not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GetCommunicationRelayers(context.Context, *GetCommunicationRelayersRequest) (*GetCommunicationRelayersResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetCommunicationRelayers not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GetExchanges(context.Context, *GetExchangesRequest) (*GetExchangesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetExchanges not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) DisableExchange(context.Context, *GenericExchangeNameRequest) (*GenericResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DisableExchange not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GetExchangeInfo(context.Context, *GenericExchangeNameRequest) (*GetExchangeInfoResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetExchangeInfo not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GetExchangeOTPCode(context.Context, *GenericExchangeNameRequest) (*GetExchangeOTPResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetExchangeOTPCode not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GetExchangeOTPCodes(context.Context, *GetExchangeOTPsRequest) (*GetExchangeOTPsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetExchangeOTPCodes not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) EnableExchange(context.Context, *GenericExchangeNameRequest) (*GenericResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method EnableExchange not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GetTicker(context.Context, *GetTickerRequest) (*TickerResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetTicker not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GetTickers(context.Context, *GetTickersRequest) (*GetTickersResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetTickers not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GetOrderbook(context.Context, *GetOrderbookRequest) (*OrderbookResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetOrderbook not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GetOrderbooks(context.Context, *GetOrderbooksRequest) (*GetOrderbooksResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetOrderbooks not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GetAccountInfo(context.Context, *GetAccountInfoRequest) (*GetAccountInfoResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetAccountInfo not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) UpdateAccountInfo(context.Context, *GetAccountInfoRequest) (*GetAccountInfoResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateAccountInfo not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GetAccountInfoStream(*GetAccountInfoRequest, GoCryptoTraderService_GetAccountInfoStreamServer) error {
	return status.Errorf(codes.Unimplemented, "method GetAccountInfoStream not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GetConfig(context.Context, *GetConfigRequest) (*GetConfigResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetConfig not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GetPortfolio(context.Context, *GetPortfolioRequest) (*GetPortfolioResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetPortfolio not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GetPortfolioSummary(context.Context, *GetPortfolioSummaryRequest) (*GetPortfolioSummaryResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetPortfolioSummary not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) AddPortfolioAddress(context.Context, *AddPortfolioAddressRequest) (*GenericResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddPortfolioAddress not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) RemovePortfolioAddress(context.Context, *RemovePortfolioAddressRequest) (*GenericResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RemovePortfolioAddress not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GetForexProviders(context.Context, *GetForexProvidersRequest) (*GetForexProvidersResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetForexProviders not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GetForexRates(context.Context, *GetForexRatesRequest) (*GetForexRatesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetForexRates not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GetOrders(context.Context, *GetOrdersRequest) (*GetOrdersResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetOrders not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GetOrder(context.Context, *GetOrderRequest) (*OrderDetails, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetOrder not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) SubmitOrder(context.Context, *SubmitOrderRequest) (*SubmitOrderResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SubmitOrder not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) SimulateOrder(context.Context, *SimulateOrderRequest) (*SimulateOrderResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SimulateOrder not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) WhaleBomb(context.Context, *WhaleBombRequest) (*SimulateOrderResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method WhaleBomb not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) CancelOrder(context.Context, *CancelOrderRequest) (*GenericResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CancelOrder not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) CancelBatchOrders(context.Context, *CancelBatchOrdersRequest) (*CancelBatchOrdersResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CancelBatchOrders not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) CancelAllOrders(context.Context, *CancelAllOrdersRequest) (*CancelAllOrdersResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CancelAllOrders not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GetEvents(context.Context, *GetEventsRequest) (*GetEventsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetEvents not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) AddEvent(context.Context, *AddEventRequest) (*AddEventResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddEvent not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) RemoveEvent(context.Context, *RemoveEventRequest) (*GenericResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RemoveEvent not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GetCryptocurrencyDepositAddresses(context.Context, *GetCryptocurrencyDepositAddressesRequest) (*GetCryptocurrencyDepositAddressesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetCryptocurrencyDepositAddresses not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GetCryptocurrencyDepositAddress(context.Context, *GetCryptocurrencyDepositAddressRequest) (*GetCryptocurrencyDepositAddressResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetCryptocurrencyDepositAddress not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GetAvailableTransferChains(context.Context, *GetAvailableTransferChainsRequest) (*GetAvailableTransferChainsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetAvailableTransferChains not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) WithdrawFiatFunds(context.Context, *WithdrawFiatRequest) (*WithdrawResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method WithdrawFiatFunds not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) WithdrawCryptocurrencyFunds(context.Context, *WithdrawCryptoRequest) (*WithdrawResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method WithdrawCryptocurrencyFunds not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) WithdrawalEventByID(context.Context, *WithdrawalEventByIDRequest) (*WithdrawalEventByIDResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method WithdrawalEventByID not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) WithdrawalEventsByExchange(context.Context, *WithdrawalEventsByExchangeRequest) (*WithdrawalEventsByExchangeResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method WithdrawalEventsByExchange not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) WithdrawalEventsByDate(context.Context, *WithdrawalEventsByDateRequest) (*WithdrawalEventsByExchangeResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method WithdrawalEventsByDate not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GetLoggerDetails(context.Context, *GetLoggerDetailsRequest) (*GetLoggerDetailsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetLoggerDetails not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) SetLoggerDetails(context.Context, *SetLoggerDetailsRequest) (*GetLoggerDetailsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetLoggerDetails not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GetExchangePairs(context.Context, *GetExchangePairsRequest) (*GetExchangePairsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetExchangePairs not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) SetExchangePair(context.Context, *SetExchangePairRequest) (*GenericResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetExchangePair not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GetOrderbookStream(*GetOrderbookStreamRequest, GoCryptoTraderService_GetOrderbookStreamServer) error {
	return status.Errorf(codes.Unimplemented, "method GetOrderbookStream not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GetExchangeOrderbookStream(*GetExchangeOrderbookStreamRequest, GoCryptoTraderService_GetExchangeOrderbookStreamServer) error {
	return status.Errorf(codes.Unimplemented, "method GetExchangeOrderbookStream not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GetTickerStream(*GetTickerStreamRequest, GoCryptoTraderService_GetTickerStreamServer) error {
	return status.Errorf(codes.Unimplemented, "method GetTickerStream not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GetExchangeTickerStream(*GetExchangeTickerStreamRequest, GoCryptoTraderService_GetExchangeTickerStreamServer) error {
	return status.Errorf(codes.Unimplemented, "method GetExchangeTickerStream not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GetAuditEvent(context.Context, *GetAuditEventRequest) (*GetAuditEventResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetAuditEvent not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GCTScriptExecute(context.Context, *GCTScriptExecuteRequest) (*GenericResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GCTScriptExecute not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GCTScriptUpload(context.Context, *GCTScriptUploadRequest) (*GenericResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GCTScriptUpload not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GCTScriptReadScript(context.Context, *GCTScriptReadScriptRequest) (*GCTScriptQueryResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GCTScriptReadScript not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GCTScriptStatus(context.Context, *GCTScriptStatusRequest) (*GCTScriptStatusResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GCTScriptStatus not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GCTScriptQuery(context.Context, *GCTScriptQueryRequest) (*GCTScriptQueryResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GCTScriptQuery not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GCTScriptStop(context.Context, *GCTScriptStopRequest) (*GenericResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GCTScriptStop not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GCTScriptStopAll(context.Context, *GCTScriptStopAllRequest) (*GenericResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GCTScriptStopAll not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GCTScriptListAll(context.Context, *GCTScriptListAllRequest) (*GCTScriptStatusResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GCTScriptListAll not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GCTScriptAutoLoadToggle(context.Context, *GCTScriptAutoLoadRequest) (*GenericResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GCTScriptAutoLoadToggle not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GetHistoricCandles(context.Context, *GetHistoricCandlesRequest) (*GetHistoricCandlesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetHistoricCandles not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) SetExchangeAsset(context.Context, *SetExchangeAssetRequest) (*GenericResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetExchangeAsset not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) SetAllExchangePairs(context.Context, *SetExchangeAllPairsRequest) (*GenericResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetAllExchangePairs not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) UpdateExchangeSupportedPairs(context.Context, *UpdateExchangeSupportedPairsRequest) (*GenericResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateExchangeSupportedPairs not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GetExchangeAssets(context.Context, *GetExchangeAssetsRequest) (*GetExchangeAssetsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetExchangeAssets not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) WebsocketGetInfo(context.Context, *WebsocketGetInfoRequest) (*WebsocketGetInfoResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method WebsocketGetInfo not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) WebsocketSetEnabled(context.Context, *WebsocketSetEnabledRequest) (*GenericResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method WebsocketSetEnabled not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) WebsocketGetSubscriptions(context.Context, *WebsocketGetSubscriptionsRequest) (*WebsocketGetSubscriptionsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method WebsocketGetSubscriptions not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) WebsocketSetProxy(context.Context, *WebsocketSetProxyRequest) (*GenericResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method WebsocketSetProxy not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) WebsocketSetURL(context.Context, *WebsocketSetURLRequest) (*GenericResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method WebsocketSetURL not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GetRecentTrades(context.Context, *GetSavedTradesRequest) (*SavedTradesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetRecentTrades not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GetHistoricTrades(*GetSavedTradesRequest, GoCryptoTraderService_GetHistoricTradesServer) error {
	return status.Errorf(codes.Unimplemented, "method GetHistoricTrades not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GetSavedTrades(context.Context, *GetSavedTradesRequest) (*SavedTradesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetSavedTrades not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) ConvertTradesToCandles(context.Context, *ConvertTradesToCandlesRequest) (*GetHistoricCandlesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ConvertTradesToCandles not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) FindMissingSavedCandleIntervals(context.Context, *FindMissingCandlePeriodsRequest) (*FindMissingIntervalsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method FindMissingSavedCandleIntervals not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) FindMissingSavedTradeIntervals(context.Context, *FindMissingTradePeriodsRequest) (*FindMissingIntervalsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method FindMissingSavedTradeIntervals not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) SetExchangeTradeProcessing(context.Context, *SetExchangeTradeProcessingRequest) (*GenericResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetExchangeTradeProcessing not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) UpsertDataHistoryJob(context.Context, *UpsertDataHistoryJobRequest) (*UpsertDataHistoryJobResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpsertDataHistoryJob not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GetDataHistoryJobDetails(context.Context, *GetDataHistoryJobDetailsRequest) (*DataHistoryJob, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetDataHistoryJobDetails not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GetActiveDataHistoryJobs(context.Context, *GetInfoRequest) (*DataHistoryJobs, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetActiveDataHistoryJobs not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GetDataHistoryJobsBetween(context.Context, *GetDataHistoryJobsBetweenRequest) (*DataHistoryJobs, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetDataHistoryJobsBetween not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GetDataHistoryJobSummary(context.Context, *GetDataHistoryJobDetailsRequest) (*DataHistoryJob, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetDataHistoryJobSummary not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) SetDataHistoryJobStatus(context.Context, *SetDataHistoryJobStatusRequest) (*GenericResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetDataHistoryJobStatus not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) UpdateDataHistoryJobPrerequisite(context.Context, *UpdateDataHistoryJobPrerequisiteRequest) (*GenericResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateDataHistoryJobPrerequisite not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GetManagedOrders(context.Context, *GetOrdersRequest) (*GetOrdersResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetManagedOrders not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) ModifyOrder(context.Context, *ModifyOrderRequest) (*ModifyOrderResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ModifyOrder not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) CurrencyStateGetAll(context.Context, *CurrencyStateGetAllRequest) (*CurrencyStateResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CurrencyStateGetAll not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) CurrencyStateTrading(context.Context, *CurrencyStateTradingRequest) (*GenericResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CurrencyStateTrading not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) CurrencyStateDeposit(context.Context, *CurrencyStateDepositRequest) (*GenericResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CurrencyStateDeposit not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) CurrencyStateWithdraw(context.Context, *CurrencyStateWithdrawRequest) (*GenericResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CurrencyStateWithdraw not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) CurrencyStateTradingPair(context.Context, *CurrencyStateTradingPairRequest) (*GenericResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CurrencyStateTradingPair not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GetFuturesPositions(context.Context, *GetFuturesPositionsRequest) (*GetFuturesPositionsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetFuturesPositions not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GetCollateral(context.Context, *GetCollateralRequest) (*GetCollateralResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetCollateral not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) Shutdown(context.Context, *ShutdownRequest) (*ShutdownResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Shutdown not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GetTechnicalAnalysis(context.Context, *GetTechnicalAnalysisRequest) (*GetTechnicalAnalysisResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetTechnicalAnalysis not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GetMarginRatesHistory(context.Context, *GetMarginRatesHistoryRequest) (*GetMarginRatesHistoryResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetMarginRatesHistory not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GetManagedPosition(context.Context, *GetManagedPositionRequest) (*GetManagedPositionsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetManagedPosition not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GetAllManagedPositions(context.Context, *GetAllManagedPositionsRequest) (*GetManagedPositionsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetAllManagedPositions not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GetFundingRates(context.Context, *GetFundingRatesRequest) (*GetFundingRatesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetFundingRates not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GetLatestFundingRate(context.Context, *GetLatestFundingRateRequest) (*GetLatestFundingRateResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetLatestFundingRate not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GetOrderbookMovement(context.Context, *GetOrderbookMovementRequest) (*GetOrderbookMovementResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetOrderbookMovement not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GetOrderbookAmountByNominal(context.Context, *GetOrderbookAmountByNominalRequest) (*GetOrderbookAmountByNominalResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetOrderbookAmountByNominal not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) GetOrderbookAmountByImpact(context.Context, *GetOrderbookAmountByImpactRequest) (*GetOrderbookAmountByImpactResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetOrderbookAmountByImpact not implemented")
}
func (UnimplementedGoCryptoTraderServiceServer) mustEmbedUnimplementedGoCryptoTraderServiceServer() {}

// UnsafeGoCryptoTraderServiceServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to GoCryptoTraderServiceServer will
// result in compilation errors.
type UnsafeGoCryptoTraderServiceServer interface {
	mustEmbedUnimplementedGoCryptoTraderServiceServer()
}

func RegisterGoCryptoTraderServiceServer(s grpc.ServiceRegistrar, srv GoCryptoTraderServiceServer) {
	s.RegisterService(&GoCryptoTraderService_ServiceDesc, srv)
}

func _GoCryptoTraderService_GetInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetInfoRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).GetInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_GetInfo_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).GetInfo(ctx, req.(*GetInfoRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_GetSubsystems_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetSubsystemsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).GetSubsystems(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_GetSubsystems_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).GetSubsystems(ctx, req.(*GetSubsystemsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_EnableSubsystem_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GenericSubsystemRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).EnableSubsystem(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_EnableSubsystem_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).EnableSubsystem(ctx, req.(*GenericSubsystemRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_DisableSubsystem_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GenericSubsystemRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).DisableSubsystem(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_DisableSubsystem_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).DisableSubsystem(ctx, req.(*GenericSubsystemRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_GetRPCEndpoints_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetRPCEndpointsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).GetRPCEndpoints(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_GetRPCEndpoints_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).GetRPCEndpoints(ctx, req.(*GetRPCEndpointsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_GetCommunicationRelayers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetCommunicationRelayersRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).GetCommunicationRelayers(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_GetCommunicationRelayers_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).GetCommunicationRelayers(ctx, req.(*GetCommunicationRelayersRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_GetExchanges_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetExchangesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).GetExchanges(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_GetExchanges_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).GetExchanges(ctx, req.(*GetExchangesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_DisableExchange_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GenericExchangeNameRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).DisableExchange(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_DisableExchange_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).DisableExchange(ctx, req.(*GenericExchangeNameRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_GetExchangeInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GenericExchangeNameRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).GetExchangeInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_GetExchangeInfo_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).GetExchangeInfo(ctx, req.(*GenericExchangeNameRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_GetExchangeOTPCode_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GenericExchangeNameRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).GetExchangeOTPCode(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_GetExchangeOTPCode_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).GetExchangeOTPCode(ctx, req.(*GenericExchangeNameRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_GetExchangeOTPCodes_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetExchangeOTPsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).GetExchangeOTPCodes(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_GetExchangeOTPCodes_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).GetExchangeOTPCodes(ctx, req.(*GetExchangeOTPsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_EnableExchange_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GenericExchangeNameRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).EnableExchange(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_EnableExchange_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).EnableExchange(ctx, req.(*GenericExchangeNameRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_GetTicker_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetTickerRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).GetTicker(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_GetTicker_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).GetTicker(ctx, req.(*GetTickerRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_GetTickers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetTickersRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).GetTickers(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_GetTickers_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).GetTickers(ctx, req.(*GetTickersRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_GetOrderbook_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetOrderbookRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).GetOrderbook(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_GetOrderbook_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).GetOrderbook(ctx, req.(*GetOrderbookRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_GetOrderbooks_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetOrderbooksRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).GetOrderbooks(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_GetOrderbooks_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).GetOrderbooks(ctx, req.(*GetOrderbooksRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_GetAccountInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetAccountInfoRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).GetAccountInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_GetAccountInfo_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).GetAccountInfo(ctx, req.(*GetAccountInfoRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_UpdateAccountInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetAccountInfoRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).UpdateAccountInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_UpdateAccountInfo_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).UpdateAccountInfo(ctx, req.(*GetAccountInfoRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_GetAccountInfoStream_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(GetAccountInfoRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(GoCryptoTraderServiceServer).GetAccountInfoStream(m, &goCryptoTraderServiceGetAccountInfoStreamServer{stream})
}

type GoCryptoTraderService_GetAccountInfoStreamServer interface {
	Send(*GetAccountInfoResponse) error
	grpc.ServerStream
}

type goCryptoTraderServiceGetAccountInfoStreamServer struct {
	grpc.ServerStream
}

func (x *goCryptoTraderServiceGetAccountInfoStreamServer) Send(m *GetAccountInfoResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _GoCryptoTraderService_GetConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).GetConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_GetConfig_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).GetConfig(ctx, req.(*GetConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_GetPortfolio_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetPortfolioRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).GetPortfolio(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_GetPortfolio_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).GetPortfolio(ctx, req.(*GetPortfolioRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_GetPortfolioSummary_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetPortfolioSummaryRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).GetPortfolioSummary(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_GetPortfolioSummary_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).GetPortfolioSummary(ctx, req.(*GetPortfolioSummaryRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_AddPortfolioAddress_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddPortfolioAddressRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).AddPortfolioAddress(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_AddPortfolioAddress_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).AddPortfolioAddress(ctx, req.(*AddPortfolioAddressRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_RemovePortfolioAddress_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RemovePortfolioAddressRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).RemovePortfolioAddress(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_RemovePortfolioAddress_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).RemovePortfolioAddress(ctx, req.(*RemovePortfolioAddressRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_GetForexProviders_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetForexProvidersRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).GetForexProviders(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_GetForexProviders_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).GetForexProviders(ctx, req.(*GetForexProvidersRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_GetForexRates_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetForexRatesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).GetForexRates(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_GetForexRates_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).GetForexRates(ctx, req.(*GetForexRatesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_GetOrders_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetOrdersRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).GetOrders(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_GetOrders_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).GetOrders(ctx, req.(*GetOrdersRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_GetOrder_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetOrderRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).GetOrder(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_GetOrder_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).GetOrder(ctx, req.(*GetOrderRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_SubmitOrder_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SubmitOrderRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).SubmitOrder(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_SubmitOrder_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).SubmitOrder(ctx, req.(*SubmitOrderRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_SimulateOrder_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SimulateOrderRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).SimulateOrder(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_SimulateOrder_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).SimulateOrder(ctx, req.(*SimulateOrderRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_WhaleBomb_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(WhaleBombRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).WhaleBomb(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_WhaleBomb_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).WhaleBomb(ctx, req.(*WhaleBombRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_CancelOrder_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CancelOrderRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).CancelOrder(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_CancelOrder_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).CancelOrder(ctx, req.(*CancelOrderRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_CancelBatchOrders_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CancelBatchOrdersRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).CancelBatchOrders(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_CancelBatchOrders_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).CancelBatchOrders(ctx, req.(*CancelBatchOrdersRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_CancelAllOrders_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CancelAllOrdersRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).CancelAllOrders(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_CancelAllOrders_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).CancelAllOrders(ctx, req.(*CancelAllOrdersRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_GetEvents_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetEventsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).GetEvents(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_GetEvents_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).GetEvents(ctx, req.(*GetEventsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_AddEvent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddEventRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).AddEvent(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_AddEvent_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).AddEvent(ctx, req.(*AddEventRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_RemoveEvent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RemoveEventRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).RemoveEvent(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_RemoveEvent_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).RemoveEvent(ctx, req.(*RemoveEventRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_GetCryptocurrencyDepositAddresses_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetCryptocurrencyDepositAddressesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).GetCryptocurrencyDepositAddresses(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_GetCryptocurrencyDepositAddresses_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).GetCryptocurrencyDepositAddresses(ctx, req.(*GetCryptocurrencyDepositAddressesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_GetCryptocurrencyDepositAddress_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetCryptocurrencyDepositAddressRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).GetCryptocurrencyDepositAddress(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_GetCryptocurrencyDepositAddress_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).GetCryptocurrencyDepositAddress(ctx, req.(*GetCryptocurrencyDepositAddressRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_GetAvailableTransferChains_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetAvailableTransferChainsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).GetAvailableTransferChains(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_GetAvailableTransferChains_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).GetAvailableTransferChains(ctx, req.(*GetAvailableTransferChainsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_WithdrawFiatFunds_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(WithdrawFiatRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).WithdrawFiatFunds(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_WithdrawFiatFunds_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).WithdrawFiatFunds(ctx, req.(*WithdrawFiatRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_WithdrawCryptocurrencyFunds_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(WithdrawCryptoRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).WithdrawCryptocurrencyFunds(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_WithdrawCryptocurrencyFunds_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).WithdrawCryptocurrencyFunds(ctx, req.(*WithdrawCryptoRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_WithdrawalEventByID_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(WithdrawalEventByIDRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).WithdrawalEventByID(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_WithdrawalEventByID_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).WithdrawalEventByID(ctx, req.(*WithdrawalEventByIDRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_WithdrawalEventsByExchange_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(WithdrawalEventsByExchangeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).WithdrawalEventsByExchange(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_WithdrawalEventsByExchange_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).WithdrawalEventsByExchange(ctx, req.(*WithdrawalEventsByExchangeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_WithdrawalEventsByDate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(WithdrawalEventsByDateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).WithdrawalEventsByDate(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_WithdrawalEventsByDate_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).WithdrawalEventsByDate(ctx, req.(*WithdrawalEventsByDateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_GetLoggerDetails_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetLoggerDetailsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).GetLoggerDetails(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_GetLoggerDetails_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).GetLoggerDetails(ctx, req.(*GetLoggerDetailsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_SetLoggerDetails_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetLoggerDetailsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).SetLoggerDetails(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_SetLoggerDetails_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).SetLoggerDetails(ctx, req.(*SetLoggerDetailsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_GetExchangePairs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetExchangePairsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).GetExchangePairs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_GetExchangePairs_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).GetExchangePairs(ctx, req.(*GetExchangePairsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_SetExchangePair_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetExchangePairRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).SetExchangePair(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_SetExchangePair_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).SetExchangePair(ctx, req.(*SetExchangePairRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_GetOrderbookStream_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(GetOrderbookStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(GoCryptoTraderServiceServer).GetOrderbookStream(m, &goCryptoTraderServiceGetOrderbookStreamServer{stream})
}

type GoCryptoTraderService_GetOrderbookStreamServer interface {
	Send(*OrderbookResponse) error
	grpc.ServerStream
}

type goCryptoTraderServiceGetOrderbookStreamServer struct {
	grpc.ServerStream
}

func (x *goCryptoTraderServiceGetOrderbookStreamServer) Send(m *OrderbookResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _GoCryptoTraderService_GetExchangeOrderbookStream_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(GetExchangeOrderbookStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(GoCryptoTraderServiceServer).GetExchangeOrderbookStream(m, &goCryptoTraderServiceGetExchangeOrderbookStreamServer{stream})
}

type GoCryptoTraderService_GetExchangeOrderbookStreamServer interface {
	Send(*OrderbookResponse) error
	grpc.ServerStream
}

type goCryptoTraderServiceGetExchangeOrderbookStreamServer struct {
	grpc.ServerStream
}

func (x *goCryptoTraderServiceGetExchangeOrderbookStreamServer) Send(m *OrderbookResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _GoCryptoTraderService_GetTickerStream_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(GetTickerStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(GoCryptoTraderServiceServer).GetTickerStream(m, &goCryptoTraderServiceGetTickerStreamServer{stream})
}

type GoCryptoTraderService_GetTickerStreamServer interface {
	Send(*TickerResponse) error
	grpc.ServerStream
}

type goCryptoTraderServiceGetTickerStreamServer struct {
	grpc.ServerStream
}

func (x *goCryptoTraderServiceGetTickerStreamServer) Send(m *TickerResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _GoCryptoTraderService_GetExchangeTickerStream_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(GetExchangeTickerStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(GoCryptoTraderServiceServer).GetExchangeTickerStream(m, &goCryptoTraderServiceGetExchangeTickerStreamServer{stream})
}

type GoCryptoTraderService_GetExchangeTickerStreamServer interface {
	Send(*TickerResponse) error
	grpc.ServerStream
}

type goCryptoTraderServiceGetExchangeTickerStreamServer struct {
	grpc.ServerStream
}

func (x *goCryptoTraderServiceGetExchangeTickerStreamServer) Send(m *TickerResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _GoCryptoTraderService_GetAuditEvent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetAuditEventRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).GetAuditEvent(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_GetAuditEvent_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).GetAuditEvent(ctx, req.(*GetAuditEventRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_GCTScriptExecute_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GCTScriptExecuteRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).GCTScriptExecute(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_GCTScriptExecute_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).GCTScriptExecute(ctx, req.(*GCTScriptExecuteRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_GCTScriptUpload_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GCTScriptUploadRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).GCTScriptUpload(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_GCTScriptUpload_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).GCTScriptUpload(ctx, req.(*GCTScriptUploadRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_GCTScriptReadScript_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GCTScriptReadScriptRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).GCTScriptReadScript(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_GCTScriptReadScript_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).GCTScriptReadScript(ctx, req.(*GCTScriptReadScriptRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_GCTScriptStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GCTScriptStatusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).GCTScriptStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_GCTScriptStatus_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).GCTScriptStatus(ctx, req.(*GCTScriptStatusRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_GCTScriptQuery_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GCTScriptQueryRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).GCTScriptQuery(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_GCTScriptQuery_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).GCTScriptQuery(ctx, req.(*GCTScriptQueryRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_GCTScriptStop_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GCTScriptStopRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).GCTScriptStop(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_GCTScriptStop_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).GCTScriptStop(ctx, req.(*GCTScriptStopRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_GCTScriptStopAll_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GCTScriptStopAllRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).GCTScriptStopAll(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_GCTScriptStopAll_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).GCTScriptStopAll(ctx, req.(*GCTScriptStopAllRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_GCTScriptListAll_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GCTScriptListAllRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).GCTScriptListAll(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_GCTScriptListAll_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).GCTScriptListAll(ctx, req.(*GCTScriptListAllRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_GCTScriptAutoLoadToggle_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GCTScriptAutoLoadRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).GCTScriptAutoLoadToggle(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_GCTScriptAutoLoadToggle_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).GCTScriptAutoLoadToggle(ctx, req.(*GCTScriptAutoLoadRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_GetHistoricCandles_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetHistoricCandlesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).GetHistoricCandles(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_GetHistoricCandles_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).GetHistoricCandles(ctx, req.(*GetHistoricCandlesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_SetExchangeAsset_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetExchangeAssetRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).SetExchangeAsset(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_SetExchangeAsset_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).SetExchangeAsset(ctx, req.(*SetExchangeAssetRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_SetAllExchangePairs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetExchangeAllPairsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).SetAllExchangePairs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_SetAllExchangePairs_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).SetAllExchangePairs(ctx, req.(*SetExchangeAllPairsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_UpdateExchangeSupportedPairs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateExchangeSupportedPairsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).UpdateExchangeSupportedPairs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_UpdateExchangeSupportedPairs_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).UpdateExchangeSupportedPairs(ctx, req.(*UpdateExchangeSupportedPairsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_GetExchangeAssets_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetExchangeAssetsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).GetExchangeAssets(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_GetExchangeAssets_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).GetExchangeAssets(ctx, req.(*GetExchangeAssetsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_WebsocketGetInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(WebsocketGetInfoRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).WebsocketGetInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_WebsocketGetInfo_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).WebsocketGetInfo(ctx, req.(*WebsocketGetInfoRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_WebsocketSetEnabled_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(WebsocketSetEnabledRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).WebsocketSetEnabled(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_WebsocketSetEnabled_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).WebsocketSetEnabled(ctx, req.(*WebsocketSetEnabledRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_WebsocketGetSubscriptions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(WebsocketGetSubscriptionsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).WebsocketGetSubscriptions(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_WebsocketGetSubscriptions_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).WebsocketGetSubscriptions(ctx, req.(*WebsocketGetSubscriptionsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_WebsocketSetProxy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(WebsocketSetProxyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).WebsocketSetProxy(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_WebsocketSetProxy_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).WebsocketSetProxy(ctx, req.(*WebsocketSetProxyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_WebsocketSetURL_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(WebsocketSetURLRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).WebsocketSetURL(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_WebsocketSetURL_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).WebsocketSetURL(ctx, req.(*WebsocketSetURLRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_GetRecentTrades_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetSavedTradesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).GetRecentTrades(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_GetRecentTrades_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).GetRecentTrades(ctx, req.(*GetSavedTradesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_GetHistoricTrades_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(GetSavedTradesRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(GoCryptoTraderServiceServer).GetHistoricTrades(m, &goCryptoTraderServiceGetHistoricTradesServer{stream})
}

type GoCryptoTraderService_GetHistoricTradesServer interface {
	Send(*SavedTradesResponse) error
	grpc.ServerStream
}

type goCryptoTraderServiceGetHistoricTradesServer struct {
	grpc.ServerStream
}

func (x *goCryptoTraderServiceGetHistoricTradesServer) Send(m *SavedTradesResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _GoCryptoTraderService_GetSavedTrades_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetSavedTradesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).GetSavedTrades(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_GetSavedTrades_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).GetSavedTrades(ctx, req.(*GetSavedTradesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_ConvertTradesToCandles_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ConvertTradesToCandlesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).ConvertTradesToCandles(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_ConvertTradesToCandles_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).ConvertTradesToCandles(ctx, req.(*ConvertTradesToCandlesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_FindMissingSavedCandleIntervals_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(FindMissingCandlePeriodsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).FindMissingSavedCandleIntervals(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_FindMissingSavedCandleIntervals_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).FindMissingSavedCandleIntervals(ctx, req.(*FindMissingCandlePeriodsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_FindMissingSavedTradeIntervals_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(FindMissingTradePeriodsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).FindMissingSavedTradeIntervals(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_FindMissingSavedTradeIntervals_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).FindMissingSavedTradeIntervals(ctx, req.(*FindMissingTradePeriodsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_SetExchangeTradeProcessing_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetExchangeTradeProcessingRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).SetExchangeTradeProcessing(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_SetExchangeTradeProcessing_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).SetExchangeTradeProcessing(ctx, req.(*SetExchangeTradeProcessingRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_UpsertDataHistoryJob_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpsertDataHistoryJobRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).UpsertDataHistoryJob(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_UpsertDataHistoryJob_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).UpsertDataHistoryJob(ctx, req.(*UpsertDataHistoryJobRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_GetDataHistoryJobDetails_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetDataHistoryJobDetailsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).GetDataHistoryJobDetails(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_GetDataHistoryJobDetails_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).GetDataHistoryJobDetails(ctx, req.(*GetDataHistoryJobDetailsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_GetActiveDataHistoryJobs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetInfoRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).GetActiveDataHistoryJobs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_GetActiveDataHistoryJobs_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).GetActiveDataHistoryJobs(ctx, req.(*GetInfoRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_GetDataHistoryJobsBetween_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetDataHistoryJobsBetweenRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).GetDataHistoryJobsBetween(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_GetDataHistoryJobsBetween_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).GetDataHistoryJobsBetween(ctx, req.(*GetDataHistoryJobsBetweenRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_GetDataHistoryJobSummary_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetDataHistoryJobDetailsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).GetDataHistoryJobSummary(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_GetDataHistoryJobSummary_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).GetDataHistoryJobSummary(ctx, req.(*GetDataHistoryJobDetailsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_SetDataHistoryJobStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetDataHistoryJobStatusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).SetDataHistoryJobStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_SetDataHistoryJobStatus_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).SetDataHistoryJobStatus(ctx, req.(*SetDataHistoryJobStatusRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_UpdateDataHistoryJobPrerequisite_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateDataHistoryJobPrerequisiteRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).UpdateDataHistoryJobPrerequisite(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_UpdateDataHistoryJobPrerequisite_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).UpdateDataHistoryJobPrerequisite(ctx, req.(*UpdateDataHistoryJobPrerequisiteRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_GetManagedOrders_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetOrdersRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).GetManagedOrders(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_GetManagedOrders_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).GetManagedOrders(ctx, req.(*GetOrdersRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_ModifyOrder_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ModifyOrderRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).ModifyOrder(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_ModifyOrder_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).ModifyOrder(ctx, req.(*ModifyOrderRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_CurrencyStateGetAll_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CurrencyStateGetAllRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).CurrencyStateGetAll(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_CurrencyStateGetAll_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).CurrencyStateGetAll(ctx, req.(*CurrencyStateGetAllRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_CurrencyStateTrading_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CurrencyStateTradingRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).CurrencyStateTrading(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_CurrencyStateTrading_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).CurrencyStateTrading(ctx, req.(*CurrencyStateTradingRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_CurrencyStateDeposit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CurrencyStateDepositRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).CurrencyStateDeposit(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_CurrencyStateDeposit_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).CurrencyStateDeposit(ctx, req.(*CurrencyStateDepositRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_CurrencyStateWithdraw_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CurrencyStateWithdrawRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).CurrencyStateWithdraw(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_CurrencyStateWithdraw_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).CurrencyStateWithdraw(ctx, req.(*CurrencyStateWithdrawRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_CurrencyStateTradingPair_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CurrencyStateTradingPairRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).CurrencyStateTradingPair(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_CurrencyStateTradingPair_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).CurrencyStateTradingPair(ctx, req.(*CurrencyStateTradingPairRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_GetFuturesPositions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetFuturesPositionsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).GetFuturesPositions(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_GetFuturesPositions_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).GetFuturesPositions(ctx, req.(*GetFuturesPositionsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_GetCollateral_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetCollateralRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).GetCollateral(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_GetCollateral_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).GetCollateral(ctx, req.(*GetCollateralRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_Shutdown_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ShutdownRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).Shutdown(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_Shutdown_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).Shutdown(ctx, req.(*ShutdownRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_GetTechnicalAnalysis_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetTechnicalAnalysisRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).GetTechnicalAnalysis(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_GetTechnicalAnalysis_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).GetTechnicalAnalysis(ctx, req.(*GetTechnicalAnalysisRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_GetMarginRatesHistory_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetMarginRatesHistoryRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).GetMarginRatesHistory(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_GetMarginRatesHistory_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).GetMarginRatesHistory(ctx, req.(*GetMarginRatesHistoryRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_GetManagedPosition_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetManagedPositionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).GetManagedPosition(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_GetManagedPosition_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).GetManagedPosition(ctx, req.(*GetManagedPositionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_GetAllManagedPositions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetAllManagedPositionsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).GetAllManagedPositions(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_GetAllManagedPositions_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).GetAllManagedPositions(ctx, req.(*GetAllManagedPositionsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_GetFundingRates_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetFundingRatesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).GetFundingRates(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_GetFundingRates_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).GetFundingRates(ctx, req.(*GetFundingRatesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_GetLatestFundingRate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetLatestFundingRateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).GetLatestFundingRate(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_GetLatestFundingRate_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).GetLatestFundingRate(ctx, req.(*GetLatestFundingRateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_GetOrderbookMovement_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetOrderbookMovementRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).GetOrderbookMovement(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_GetOrderbookMovement_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).GetOrderbookMovement(ctx, req.(*GetOrderbookMovementRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_GetOrderbookAmountByNominal_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetOrderbookAmountByNominalRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).GetOrderbookAmountByNominal(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_GetOrderbookAmountByNominal_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).GetOrderbookAmountByNominal(ctx, req.(*GetOrderbookAmountByNominalRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTraderService_GetOrderbookAmountByImpact_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetOrderbookAmountByImpactRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServiceServer).GetOrderbookAmountByImpact(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoCryptoTraderService_GetOrderbookAmountByImpact_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).GetOrderbookAmountByImpact(ctx, req.(*GetOrderbookAmountByImpactRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// GoCryptoTraderService_ServiceDesc is the grpc.ServiceDesc for GoCryptoTraderService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var GoCryptoTraderService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "gctrpc.GoCryptoTraderService",
	HandlerType: (*GoCryptoTraderServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetInfo",
			Handler:    _GoCryptoTraderService_GetInfo_Handler,
		},
		{
			MethodName: "GetSubsystems",
			Handler:    _GoCryptoTraderService_GetSubsystems_Handler,
		},
		{
			MethodName: "EnableSubsystem",
			Handler:    _GoCryptoTraderService_EnableSubsystem_Handler,
		},
		{
			MethodName: "DisableSubsystem",
			Handler:    _GoCryptoTraderService_DisableSubsystem_Handler,
		},
		{
			MethodName: "GetRPCEndpoints",
			Handler:    _GoCryptoTraderService_GetRPCEndpoints_Handler,
		},
		{
			MethodName: "GetCommunicationRelayers",
			Handler:    _GoCryptoTraderService_GetCommunicationRelayers_Handler,
		},
		{
			MethodName: "GetExchanges",
			Handler:    _GoCryptoTraderService_GetExchanges_Handler,
		},
		{
			MethodName: "DisableExchange",
			Handler:    _GoCryptoTraderService_DisableExchange_Handler,
		},
		{
			MethodName: "GetExchangeInfo",
			Handler:    _GoCryptoTraderService_GetExchangeInfo_Handler,
		},
		{
			MethodName: "GetExchangeOTPCode",
			Handler:    _GoCryptoTraderService_GetExchangeOTPCode_Handler,
		},
		{
			MethodName: "GetExchangeOTPCodes",
			Handler:    _GoCryptoTraderService_GetExchangeOTPCodes_Handler,
		},
		{
			MethodName: "EnableExchange",
			Handler:    _GoCryptoTraderService_EnableExchange_Handler,
		},
		{
			MethodName: "GetTicker",
			Handler:    _GoCryptoTraderService_GetTicker_Handler,
		},
		{
			MethodName: "GetTickers",
			Handler:    _GoCryptoTraderService_GetTickers_Handler,
		},
		{
			MethodName: "GetOrderbook",
			Handler:    _GoCryptoTraderService_GetOrderbook_Handler,
		},
		{
			MethodName: "GetOrderbooks",
			Handler:    _GoCryptoTraderService_GetOrderbooks_Handler,
		},
		{
			MethodName: "GetAccountInfo",
			Handler:    _GoCryptoTraderService_GetAccountInfo_Handler,
		},
		{
			MethodName: "UpdateAccountInfo",
			Handler:    _GoCryptoTraderService_UpdateAccountInfo_Handler,
		},
		{
			MethodName: "GetConfig",
			Handler:    _GoCryptoTraderService_GetConfig_Handler,
		},
		{
			MethodName: "GetPortfolio",
			Handler:    _GoCryptoTraderService_GetPortfolio_Handler,
		},
		{
			MethodName: "GetPortfolioSummary",
			Handler:    _GoCryptoTraderService_GetPortfolioSummary_Handler,
		},
		{
			MethodName: "AddPortfolioAddress",
			Handler:    _GoCryptoTraderService_AddPortfolioAddress_Handler,
		},
		{
			MethodName: "RemovePortfolioAddress",
			Handler:    _GoCryptoTraderService_RemovePortfolioAddress_Handler,
		},
		{
			MethodName: "GetForexProviders",
			Handler:    _GoCryptoTraderService_GetForexProviders_Handler,
		},
		{
			MethodName: "GetForexRates",
			Handler:    _GoCryptoTraderService_GetForexRates_Handler,
		},
		{
			MethodName: "GetOrders",
			Handler:    _GoCryptoTraderService_GetOrders_Handler,
		},
		{
			MethodName: "GetOrder",
			Handler:    _GoCryptoTraderService_GetOrder_Handler,
		},
		{
			MethodName: "SubmitOrder",
			Handler:    _GoCryptoTraderService_SubmitOrder_Handler,
		},
		{
			MethodName: "SimulateOrder",
			Handler:    _GoCryptoTraderService_SimulateOrder_Handler,
		},
		{
			MethodName: "WhaleBomb",
			Handler:    _GoCryptoTraderService_WhaleBomb_Handler,
		},
		{
			MethodName: "CancelOrder",
			Handler:    _GoCryptoTraderService_CancelOrder_Handler,
		},
		{
			MethodName: "CancelBatchOrders",
			Handler:    _GoCryptoTraderService_CancelBatchOrders_Handler,
		},
		{
			MethodName: "CancelAllOrders",
			Handler:    _GoCryptoTraderService_CancelAllOrders_Handler,
		},
		{
			MethodName: "GetEvents",
			Handler:    _GoCryptoTraderService_GetEvents_Handler,
		},
		{
			MethodName: "AddEvent",
			Handler:    _GoCryptoTraderService_AddEvent_Handler,
		},
		{
			MethodName: "RemoveEvent",
			Handler:    _GoCryptoTraderService_RemoveEvent_Handler,
		},
		{
			MethodName: "GetCryptocurrencyDepositAddresses",
			Handler:    _GoCryptoTraderService_GetCryptocurrencyDepositAddresses_Handler,
		},
		{
			MethodName: "GetCryptocurrencyDepositAddress",
			Handler:    _GoCryptoTraderService_GetCryptocurrencyDepositAddress_Handler,
		},
		{
			MethodName: "GetAvailableTransferChains",
			Handler:    _GoCryptoTraderService_GetAvailableTransferChains_Handler,
		},
		{
			MethodName: "WithdrawFiatFunds",
			Handler:    _GoCryptoTraderService_WithdrawFiatFunds_Handler,
		},
		{
			MethodName: "WithdrawCryptocurrencyFunds",
			Handler:    _GoCryptoTraderService_WithdrawCryptocurrencyFunds_Handler,
		},
		{
			MethodName: "WithdrawalEventByID",
			Handler:    _GoCryptoTraderService_WithdrawalEventByID_Handler,
		},
		{
			MethodName: "WithdrawalEventsByExchange",
			Handler:    _GoCryptoTraderService_WithdrawalEventsByExchange_Handler,
		},
		{
			MethodName: "WithdrawalEventsByDate",
			Handler:    _GoCryptoTraderService_WithdrawalEventsByDate_Handler,
		},
		{
			MethodName: "GetLoggerDetails",
			Handler:    _GoCryptoTraderService_GetLoggerDetails_Handler,
		},
		{
			MethodName: "SetLoggerDetails",
			Handler:    _GoCryptoTraderService_SetLoggerDetails_Handler,
		},
		{
			MethodName: "GetExchangePairs",
			Handler:    _GoCryptoTraderService_GetExchangePairs_Handler,
		},
		{
			MethodName: "SetExchangePair",
			Handler:    _GoCryptoTraderService_SetExchangePair_Handler,
		},
		{
			MethodName: "GetAuditEvent",
			Handler:    _GoCryptoTraderService_GetAuditEvent_Handler,
		},
		{
			MethodName: "GCTScriptExecute",
			Handler:    _GoCryptoTraderService_GCTScriptExecute_Handler,
		},
		{
			MethodName: "GCTScriptUpload",
			Handler:    _GoCryptoTraderService_GCTScriptUpload_Handler,
		},
		{
			MethodName: "GCTScriptReadScript",
			Handler:    _GoCryptoTraderService_GCTScriptReadScript_Handler,
		},
		{
			MethodName: "GCTScriptStatus",
			Handler:    _GoCryptoTraderService_GCTScriptStatus_Handler,
		},
		{
			MethodName: "GCTScriptQuery",
			Handler:    _GoCryptoTraderService_GCTScriptQuery_Handler,
		},
		{
			MethodName: "GCTScriptStop",
			Handler:    _GoCryptoTraderService_GCTScriptStop_Handler,
		},
		{
			MethodName: "GCTScriptStopAll",
			Handler:    _GoCryptoTraderService_GCTScriptStopAll_Handler,
		},
		{
			MethodName: "GCTScriptListAll",
			Handler:    _GoCryptoTraderService_GCTScriptListAll_Handler,
		},
		{
			MethodName: "GCTScriptAutoLoadToggle",
			Handler:    _GoCryptoTraderService_GCTScriptAutoLoadToggle_Handler,
		},
		{
			MethodName: "GetHistoricCandles",
			Handler:    _GoCryptoTraderService_GetHistoricCandles_Handler,
		},
		{
			MethodName: "SetExchangeAsset",
			Handler:    _GoCryptoTraderService_SetExchangeAsset_Handler,
		},
		{
			MethodName: "SetAllExchangePairs",
			Handler:    _GoCryptoTraderService_SetAllExchangePairs_Handler,
		},
		{
			MethodName: "UpdateExchangeSupportedPairs",
			Handler:    _GoCryptoTraderService_UpdateExchangeSupportedPairs_Handler,
		},
		{
			MethodName: "GetExchangeAssets",
			Handler:    _GoCryptoTraderService_GetExchangeAssets_Handler,
		},
		{
			MethodName: "WebsocketGetInfo",
			Handler:    _GoCryptoTraderService_WebsocketGetInfo_Handler,
		},
		{
			MethodName: "WebsocketSetEnabled",
			Handler:    _GoCryptoTraderService_WebsocketSetEnabled_Handler,
		},
		{
			MethodName: "WebsocketGetSubscriptions",
			Handler:    _GoCryptoTraderService_WebsocketGetSubscriptions_Handler,
		},
		{
			MethodName: "WebsocketSetProxy",
			Handler:    _GoCryptoTraderService_WebsocketSetProxy_Handler,
		},
		{
			MethodName: "WebsocketSetURL",
			Handler:    _GoCryptoTraderService_WebsocketSetURL_Handler,
		},
		{
			MethodName: "GetRecentTrades",
			Handler:    _GoCryptoTraderService_GetRecentTrades_Handler,
		},
		{
			MethodName: "GetSavedTrades",
			Handler:    _GoCryptoTraderService_GetSavedTrades_Handler,
		},
		{
			MethodName: "ConvertTradesToCandles",
			Handler:    _GoCryptoTraderService_ConvertTradesToCandles_Handler,
		},
		{
			MethodName: "FindMissingSavedCandleIntervals",
			Handler:    _GoCryptoTraderService_FindMissingSavedCandleIntervals_Handler,
		},
		{
			MethodName: "FindMissingSavedTradeIntervals",
			Handler:    _GoCryptoTraderService_FindMissingSavedTradeIntervals_Handler,
		},
		{
			MethodName: "SetExchangeTradeProcessing",
			Handler:    _GoCryptoTraderService_SetExchangeTradeProcessing_Handler,
		},
		{
			MethodName: "UpsertDataHistoryJob",
			Handler:    _GoCryptoTraderService_UpsertDataHistoryJob_Handler,
		},
		{
			MethodName: "GetDataHistoryJobDetails",
			Handler:    _GoCryptoTraderService_GetDataHistoryJobDetails_Handler,
		},
		{
			MethodName: "GetActiveDataHistoryJobs",
			Handler:    _GoCryptoTraderService_GetActiveDataHistoryJobs_Handler,
		},
		{
			MethodName: "GetDataHistoryJobsBetween",
			Handler:    _GoCryptoTraderService_GetDataHistoryJobsBetween_Handler,
		},
		{
			MethodName: "GetDataHistoryJobSummary",
			Handler:    _GoCryptoTraderService_GetDataHistoryJobSummary_Handler,
		},
		{
			MethodName: "SetDataHistoryJobStatus",
			Handler:    _GoCryptoTraderService_SetDataHistoryJobStatus_Handler,
		},
		{
			MethodName: "UpdateDataHistoryJobPrerequisite",
			Handler:    _GoCryptoTraderService_UpdateDataHistoryJobPrerequisite_Handler,
		},
		{
			MethodName: "GetManagedOrders",
			Handler:    _GoCryptoTraderService_GetManagedOrders_Handler,
		},
		{
			MethodName: "ModifyOrder",
			Handler:    _GoCryptoTraderService_ModifyOrder_Handler,
		},
		{
			MethodName: "CurrencyStateGetAll",
			Handler:    _GoCryptoTraderService_CurrencyStateGetAll_Handler,
		},
		{
			MethodName: "CurrencyStateTrading",
			Handler:    _GoCryptoTraderService_CurrencyStateTrading_Handler,
		},
		{
			MethodName: "CurrencyStateDeposit",
			Handler:    _GoCryptoTraderService_CurrencyStateDeposit_Handler,
		},
		{
			MethodName: "CurrencyStateWithdraw",
			Handler:    _GoCryptoTraderService_CurrencyStateWithdraw_Handler,
		},
		{
			MethodName: "CurrencyStateTradingPair",
			Handler:    _GoCryptoTraderService_CurrencyStateTradingPair_Handler,
		},
		{
			MethodName: "GetFuturesPositions",
			Handler:    _GoCryptoTraderService_GetFuturesPositions_Handler,
		},
		{
			MethodName: "GetCollateral",
			Handler:    _GoCryptoTraderService_GetCollateral_Handler,
		},
		{
			MethodName: "Shutdown",
			Handler:    _GoCryptoTraderService_Shutdown_Handler,
		},
		{
			MethodName: "GetTechnicalAnalysis",
			Handler:    _GoCryptoTraderService_GetTechnicalAnalysis_Handler,
		},
		{
			MethodName: "GetMarginRatesHistory",
			Handler:    _GoCryptoTraderService_GetMarginRatesHistory_Handler,
		},
		{
			MethodName: "GetManagedPosition",
			Handler:    _GoCryptoTraderService_GetManagedPosition_Handler,
		},
		{
			MethodName: "GetAllManagedPositions",
			Handler:    _GoCryptoTraderService_GetAllManagedPositions_Handler,
		},
		{
			MethodName: "GetFundingRates",
			Handler:    _GoCryptoTraderService_GetFundingRates_Handler,
		},
		{
			MethodName: "GetLatestFundingRate",
			Handler:    _GoCryptoTraderService_GetLatestFundingRate_Handler,
		},
		{
			MethodName: "GetOrderbookMovement",
			Handler:    _GoCryptoTraderService_GetOrderbookMovement_Handler,
		},
		{
			MethodName: "GetOrderbookAmountByNominal",
			Handler:    _GoCryptoTraderService_GetOrderbookAmountByNominal_Handler,
		},
		{
			MethodName: "GetOrderbookAmountByImpact",
			Handler:    _GoCryptoTraderService_GetOrderbookAmountByImpact_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "GetAccountInfoStream",
			Handler:       _GoCryptoTraderService_GetAccountInfoStream_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "GetOrderbookStream",
			Handler:       _GoCryptoTraderService_GetOrderbookStream_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "GetExchangeOrderbookStream",
			Handler:       _GoCryptoTraderService_GetExchangeOrderbookStream_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "GetTickerStream",
			Handler:       _GoCryptoTraderService_GetTickerStream_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "GetExchangeTickerStream",
			Handler:       _GoCryptoTraderService_GetExchangeTickerStream_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "GetHistoricTrades",
			Handler:       _GoCryptoTraderService_GetHistoricTrades_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "rpc.proto",
}
