gocryptotrader/gctrpc/rpc_grpc.pb.go

// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.2.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

// 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)
}

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, "/gctrpc.GoCryptoTraderService/GetInfo", 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, "/gctrpc.GoCryptoTraderService/GetSubsystems", 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, "/gctrpc.GoCryptoTraderService/EnableSubsystem", 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, "/gctrpc.GoCryptoTraderService/DisableSubsystem", 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, "/gctrpc.GoCryptoTraderService/GetRPCEndpoints", 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, "/gctrpc.GoCryptoTraderService/GetCommunicationRelayers", 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, "/gctrpc.GoCryptoTraderService/GetExchanges", 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, "/gctrpc.GoCryptoTraderService/DisableExchange", 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, "/gctrpc.GoCryptoTraderService/GetExchangeInfo", 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, "/gctrpc.GoCryptoTraderService/GetExchangeOTPCode", 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, "/gctrpc.GoCryptoTraderService/GetExchangeOTPCodes", 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, "/gctrpc.GoCryptoTraderService/EnableExchange", 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, "/gctrpc.GoCryptoTraderService/GetTicker", 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, "/gctrpc.GoCryptoTraderService/GetTickers", 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, "/gctrpc.GoCryptoTraderService/GetOrderbook", 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, "/gctrpc.GoCryptoTraderService/GetOrderbooks", 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, "/gctrpc.GoCryptoTraderService/GetAccountInfo", 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, "/gctrpc.GoCryptoTraderService/UpdateAccountInfo", 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], "/gctrpc.GoCryptoTraderService/GetAccountInfoStream", 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, "/gctrpc.GoCryptoTraderService/GetConfig", 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, "/gctrpc.GoCryptoTraderService/GetPortfolio", 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, "/gctrpc.GoCryptoTraderService/GetPortfolioSummary", 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, "/gctrpc.GoCryptoTraderService/AddPortfolioAddress", 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, "/gctrpc.GoCryptoTraderService/RemovePortfolioAddress", 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, "/gctrpc.GoCryptoTraderService/GetForexProviders", 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, "/gctrpc.GoCryptoTraderService/GetForexRates", 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, "/gctrpc.GoCryptoTraderService/GetOrders", 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, "/gctrpc.GoCryptoTraderService/GetOrder", 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, "/gctrpc.GoCryptoTraderService/SubmitOrder", 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, "/gctrpc.GoCryptoTraderService/SimulateOrder", 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, "/gctrpc.GoCryptoTraderService/WhaleBomb", 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, "/gctrpc.GoCryptoTraderService/CancelOrder", 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, "/gctrpc.GoCryptoTraderService/CancelBatchOrders", 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, "/gctrpc.GoCryptoTraderService/CancelAllOrders", 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, "/gctrpc.GoCryptoTraderService/GetEvents", 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, "/gctrpc.GoCryptoTraderService/AddEvent", 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, "/gctrpc.GoCryptoTraderService/RemoveEvent", 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, "/gctrpc.GoCryptoTraderService/GetCryptocurrencyDepositAddresses", 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, "/gctrpc.GoCryptoTraderService/GetCryptocurrencyDepositAddress", 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, "/gctrpc.GoCryptoTraderService/GetAvailableTransferChains", 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, "/gctrpc.GoCryptoTraderService/WithdrawFiatFunds", 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, "/gctrpc.GoCryptoTraderService/WithdrawCryptocurrencyFunds", 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, "/gctrpc.GoCryptoTraderService/WithdrawalEventByID", 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, "/gctrpc.GoCryptoTraderService/WithdrawalEventsByExchange", 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, "/gctrpc.GoCryptoTraderService/WithdrawalEventsByDate", 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, "/gctrpc.GoCryptoTraderService/GetLoggerDetails", 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, "/gctrpc.GoCryptoTraderService/SetLoggerDetails", 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, "/gctrpc.GoCryptoTraderService/GetExchangePairs", 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, "/gctrpc.GoCryptoTraderService/SetExchangePair", 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], "/gctrpc.GoCryptoTraderService/GetOrderbookStream", 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], "/gctrpc.GoCryptoTraderService/GetExchangeOrderbookStream", 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], "/gctrpc.GoCryptoTraderService/GetTickerStream", 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], "/gctrpc.GoCryptoTraderService/GetExchangeTickerStream", 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, "/gctrpc.GoCryptoTraderService/GetAuditEvent", 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, "/gctrpc.GoCryptoTraderService/GCTScriptExecute", 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, "/gctrpc.GoCryptoTraderService/GCTScriptUpload", 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, "/gctrpc.GoCryptoTraderService/GCTScriptReadScript", 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, "/gctrpc.GoCryptoTraderService/GCTScriptStatus", 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, "/gctrpc.GoCryptoTraderService/GCTScriptQuery", 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, "/gctrpc.GoCryptoTraderService/GCTScriptStop", 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, "/gctrpc.GoCryptoTraderService/GCTScriptStopAll", 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, "/gctrpc.GoCryptoTraderService/GCTScriptListAll", 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, "/gctrpc.GoCryptoTraderService/GCTScriptAutoLoadToggle", 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, "/gctrpc.GoCryptoTraderService/GetHistoricCandles", 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, "/gctrpc.GoCryptoTraderService/SetExchangeAsset", 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, "/gctrpc.GoCryptoTraderService/SetAllExchangePairs", 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, "/gctrpc.GoCryptoTraderService/UpdateExchangeSupportedPairs", 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, "/gctrpc.GoCryptoTraderService/GetExchangeAssets", 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, "/gctrpc.GoCryptoTraderService/WebsocketGetInfo", 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, "/gctrpc.GoCryptoTraderService/WebsocketSetEnabled", 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, "/gctrpc.GoCryptoTraderService/WebsocketGetSubscriptions", 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, "/gctrpc.GoCryptoTraderService/WebsocketSetProxy", 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, "/gctrpc.GoCryptoTraderService/WebsocketSetURL", 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, "/gctrpc.GoCryptoTraderService/GetRecentTrades", 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], "/gctrpc.GoCryptoTraderService/GetHistoricTrades", 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, "/gctrpc.GoCryptoTraderService/GetSavedTrades", 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, "/gctrpc.GoCryptoTraderService/ConvertTradesToCandles", 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, "/gctrpc.GoCryptoTraderService/FindMissingSavedCandleIntervals", 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, "/gctrpc.GoCryptoTraderService/FindMissingSavedTradeIntervals", 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, "/gctrpc.GoCryptoTraderService/SetExchangeTradeProcessing", 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, "/gctrpc.GoCryptoTraderService/UpsertDataHistoryJob", 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, "/gctrpc.GoCryptoTraderService/GetDataHistoryJobDetails", 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, "/gctrpc.GoCryptoTraderService/GetActiveDataHistoryJobs", 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, "/gctrpc.GoCryptoTraderService/GetDataHistoryJobsBetween", 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, "/gctrpc.GoCryptoTraderService/GetDataHistoryJobSummary", 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, "/gctrpc.GoCryptoTraderService/SetDataHistoryJobStatus", 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, "/gctrpc.GoCryptoTraderService/UpdateDataHistoryJobPrerequisite", 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, "/gctrpc.GoCryptoTraderService/GetManagedOrders", 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, "/gctrpc.GoCryptoTraderService/ModifyOrder", 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, "/gctrpc.GoCryptoTraderService/CurrencyStateGetAll", 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, "/gctrpc.GoCryptoTraderService/CurrencyStateTrading", 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, "/gctrpc.GoCryptoTraderService/CurrencyStateDeposit", 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, "/gctrpc.GoCryptoTraderService/CurrencyStateWithdraw", 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, "/gctrpc.GoCryptoTraderService/CurrencyStateTradingPair", 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, "/gctrpc.GoCryptoTraderService/GetFuturesPositions", 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, "/gctrpc.GoCryptoTraderService/GetCollateral", 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, "/gctrpc.GoCryptoTraderService/Shutdown", 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)
	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) 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: "/gctrpc.GoCryptoTraderService/GetInfo",
	}
	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: "/gctrpc.GoCryptoTraderService/GetSubsystems",
	}
	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: "/gctrpc.GoCryptoTraderService/EnableSubsystem",
	}
	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: "/gctrpc.GoCryptoTraderService/DisableSubsystem",
	}
	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: "/gctrpc.GoCryptoTraderService/GetRPCEndpoints",
	}
	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: "/gctrpc.GoCryptoTraderService/GetCommunicationRelayers",
	}
	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: "/gctrpc.GoCryptoTraderService/GetExchanges",
	}
	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: "/gctrpc.GoCryptoTraderService/DisableExchange",
	}
	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: "/gctrpc.GoCryptoTraderService/GetExchangeInfo",
	}
	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: "/gctrpc.GoCryptoTraderService/GetExchangeOTPCode",
	}
	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: "/gctrpc.GoCryptoTraderService/GetExchangeOTPCodes",
	}
	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: "/gctrpc.GoCryptoTraderService/EnableExchange",
	}
	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: "/gctrpc.GoCryptoTraderService/GetTicker",
	}
	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: "/gctrpc.GoCryptoTraderService/GetTickers",
	}
	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: "/gctrpc.GoCryptoTraderService/GetOrderbook",
	}
	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: "/gctrpc.GoCryptoTraderService/GetOrderbooks",
	}
	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: "/gctrpc.GoCryptoTraderService/GetAccountInfo",
	}
	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: "/gctrpc.GoCryptoTraderService/UpdateAccountInfo",
	}
	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: "/gctrpc.GoCryptoTraderService/GetConfig",
	}
	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: "/gctrpc.GoCryptoTraderService/GetPortfolio",
	}
	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: "/gctrpc.GoCryptoTraderService/GetPortfolioSummary",
	}
	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: "/gctrpc.GoCryptoTraderService/AddPortfolioAddress",
	}
	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: "/gctrpc.GoCryptoTraderService/RemovePortfolioAddress",
	}
	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: "/gctrpc.GoCryptoTraderService/GetForexProviders",
	}
	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: "/gctrpc.GoCryptoTraderService/GetForexRates",
	}
	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: "/gctrpc.GoCryptoTraderService/GetOrders",
	}
	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: "/gctrpc.GoCryptoTraderService/GetOrder",
	}
	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: "/gctrpc.GoCryptoTraderService/SubmitOrder",
	}
	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: "/gctrpc.GoCryptoTraderService/SimulateOrder",
	}
	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: "/gctrpc.GoCryptoTraderService/WhaleBomb",
	}
	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: "/gctrpc.GoCryptoTraderService/CancelOrder",
	}
	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: "/gctrpc.GoCryptoTraderService/CancelBatchOrders",
	}
	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: "/gctrpc.GoCryptoTraderService/CancelAllOrders",
	}
	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: "/gctrpc.GoCryptoTraderService/GetEvents",
	}
	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: "/gctrpc.GoCryptoTraderService/AddEvent",
	}
	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: "/gctrpc.GoCryptoTraderService/RemoveEvent",
	}
	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: "/gctrpc.GoCryptoTraderService/GetCryptocurrencyDepositAddresses",
	}
	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: "/gctrpc.GoCryptoTraderService/GetCryptocurrencyDepositAddress",
	}
	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: "/gctrpc.GoCryptoTraderService/GetAvailableTransferChains",
	}
	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: "/gctrpc.GoCryptoTraderService/WithdrawFiatFunds",
	}
	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: "/gctrpc.GoCryptoTraderService/WithdrawCryptocurrencyFunds",
	}
	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: "/gctrpc.GoCryptoTraderService/WithdrawalEventByID",
	}
	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: "/gctrpc.GoCryptoTraderService/WithdrawalEventsByExchange",
	}
	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: "/gctrpc.GoCryptoTraderService/WithdrawalEventsByDate",
	}
	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: "/gctrpc.GoCryptoTraderService/GetLoggerDetails",
	}
	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: "/gctrpc.GoCryptoTraderService/SetLoggerDetails",
	}
	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: "/gctrpc.GoCryptoTraderService/GetExchangePairs",
	}
	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: "/gctrpc.GoCryptoTraderService/SetExchangePair",
	}
	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: "/gctrpc.GoCryptoTraderService/GetAuditEvent",
	}
	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: "/gctrpc.GoCryptoTraderService/GCTScriptExecute",
	}
	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: "/gctrpc.GoCryptoTraderService/GCTScriptUpload",
	}
	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: "/gctrpc.GoCryptoTraderService/GCTScriptReadScript",
	}
	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: "/gctrpc.GoCryptoTraderService/GCTScriptStatus",
	}
	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: "/gctrpc.GoCryptoTraderService/GCTScriptQuery",
	}
	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: "/gctrpc.GoCryptoTraderService/GCTScriptStop",
	}
	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: "/gctrpc.GoCryptoTraderService/GCTScriptStopAll",
	}
	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: "/gctrpc.GoCryptoTraderService/GCTScriptListAll",
	}
	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: "/gctrpc.GoCryptoTraderService/GCTScriptAutoLoadToggle",
	}
	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: "/gctrpc.GoCryptoTraderService/GetHistoricCandles",
	}
	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: "/gctrpc.GoCryptoTraderService/SetExchangeAsset",
	}
	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: "/gctrpc.GoCryptoTraderService/SetAllExchangePairs",
	}
	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: "/gctrpc.GoCryptoTraderService/UpdateExchangeSupportedPairs",
	}
	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: "/gctrpc.GoCryptoTraderService/GetExchangeAssets",
	}
	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: "/gctrpc.GoCryptoTraderService/WebsocketGetInfo",
	}
	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: "/gctrpc.GoCryptoTraderService/WebsocketSetEnabled",
	}
	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: "/gctrpc.GoCryptoTraderService/WebsocketGetSubscriptions",
	}
	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: "/gctrpc.GoCryptoTraderService/WebsocketSetProxy",
	}
	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: "/gctrpc.GoCryptoTraderService/WebsocketSetURL",
	}
	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: "/gctrpc.GoCryptoTraderService/GetRecentTrades",
	}
	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: "/gctrpc.GoCryptoTraderService/GetSavedTrades",
	}
	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: "/gctrpc.GoCryptoTraderService/ConvertTradesToCandles",
	}
	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: "/gctrpc.GoCryptoTraderService/FindMissingSavedCandleIntervals",
	}
	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: "/gctrpc.GoCryptoTraderService/FindMissingSavedTradeIntervals",
	}
	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: "/gctrpc.GoCryptoTraderService/SetExchangeTradeProcessing",
	}
	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: "/gctrpc.GoCryptoTraderService/UpsertDataHistoryJob",
	}
	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: "/gctrpc.GoCryptoTraderService/GetDataHistoryJobDetails",
	}
	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: "/gctrpc.GoCryptoTraderService/GetActiveDataHistoryJobs",
	}
	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: "/gctrpc.GoCryptoTraderService/GetDataHistoryJobsBetween",
	}
	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: "/gctrpc.GoCryptoTraderService/GetDataHistoryJobSummary",
	}
	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: "/gctrpc.GoCryptoTraderService/SetDataHistoryJobStatus",
	}
	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: "/gctrpc.GoCryptoTraderService/UpdateDataHistoryJobPrerequisite",
	}
	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: "/gctrpc.GoCryptoTraderService/GetManagedOrders",
	}
	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: "/gctrpc.GoCryptoTraderService/ModifyOrder",
	}
	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: "/gctrpc.GoCryptoTraderService/CurrencyStateGetAll",
	}
	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: "/gctrpc.GoCryptoTraderService/CurrencyStateTrading",
	}
	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: "/gctrpc.GoCryptoTraderService/CurrencyStateDeposit",
	}
	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: "/gctrpc.GoCryptoTraderService/CurrencyStateWithdraw",
	}
	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: "/gctrpc.GoCryptoTraderService/CurrencyStateTradingPair",
	}
	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: "/gctrpc.GoCryptoTraderService/GetFuturesPositions",
	}
	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: "/gctrpc.GoCryptoTraderService/GetCollateral",
	}
	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: "/gctrpc.GoCryptoTraderService/Shutdown",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServiceServer).Shutdown(ctx, req.(*ShutdownRequest))
	}
	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,
		},
	},
	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",
}