// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/c9s/bbgo/pkg/types (interfaces: Exchange)
//
// Generated by this command:
//
//	mockgen -destination=mocks/mock_exchange.go -package=mocks . Exchange
//

// Package mocks is a generated GoMock package.
package mocks

import (
	context "context"
	reflect "reflect"

	types "github.com/c9s/bbgo/pkg/types"
	gomock "go.uber.org/mock/gomock"
)

// MockExchange is a mock of Exchange interface.
type MockExchange struct {
	ctrl     *gomock.Controller
	recorder *MockExchangeMockRecorder
	isgomock struct{}
}

// MockExchangeMockRecorder is the mock recorder for MockExchange.
type MockExchangeMockRecorder struct {
	mock *MockExchange
}

// NewMockExchange creates a new mock instance.
func NewMockExchange(ctrl *gomock.Controller) *MockExchange {
	mock := &MockExchange{ctrl: ctrl}
	mock.recorder = &MockExchangeMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockExchange) EXPECT() *MockExchangeMockRecorder {
	return m.recorder
}

// CancelOrders mocks base method.
func (m *MockExchange) CancelOrders(ctx context.Context, orders ...types.Order) error {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range orders {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CancelOrders", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// CancelOrders indicates an expected call of CancelOrders.
func (mr *MockExchangeMockRecorder) CancelOrders(ctx any, orders ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, orders...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelOrders", reflect.TypeOf((*MockExchange)(nil).CancelOrders), varargs...)
}

// Name mocks base method.
func (m *MockExchange) Name() types.ExchangeName {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Name")
	ret0, _ := ret[0].(types.ExchangeName)
	return ret0
}

// Name indicates an expected call of Name.
func (mr *MockExchangeMockRecorder) Name() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockExchange)(nil).Name))
}

// NewStream mocks base method.
func (m *MockExchange) NewStream() types.Stream {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewStream")
	ret0, _ := ret[0].(types.Stream)
	return ret0
}

// NewStream indicates an expected call of NewStream.
func (mr *MockExchangeMockRecorder) NewStream() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewStream", reflect.TypeOf((*MockExchange)(nil).NewStream))
}

// PlatformFeeCurrency mocks base method.
func (m *MockExchange) PlatformFeeCurrency() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PlatformFeeCurrency")
	ret0, _ := ret[0].(string)
	return ret0
}

// PlatformFeeCurrency indicates an expected call of PlatformFeeCurrency.
func (mr *MockExchangeMockRecorder) PlatformFeeCurrency() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PlatformFeeCurrency", reflect.TypeOf((*MockExchange)(nil).PlatformFeeCurrency))
}

// QueryAccount mocks base method.
func (m *MockExchange) QueryAccount(ctx context.Context) (*types.Account, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryAccount", ctx)
	ret0, _ := ret[0].(*types.Account)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// QueryAccount indicates an expected call of QueryAccount.
func (mr *MockExchangeMockRecorder) QueryAccount(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryAccount", reflect.TypeOf((*MockExchange)(nil).QueryAccount), ctx)
}

// QueryAccountBalances mocks base method.
func (m *MockExchange) QueryAccountBalances(ctx context.Context) (types.BalanceMap, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryAccountBalances", ctx)
	ret0, _ := ret[0].(types.BalanceMap)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// QueryAccountBalances indicates an expected call of QueryAccountBalances.
func (mr *MockExchangeMockRecorder) QueryAccountBalances(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryAccountBalances", reflect.TypeOf((*MockExchange)(nil).QueryAccountBalances), ctx)
}

// QueryKLines mocks base method.
func (m *MockExchange) QueryKLines(ctx context.Context, symbol string, interval types.Interval, options types.KLineQueryOptions) ([]types.KLine, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryKLines", ctx, symbol, interval, options)
	ret0, _ := ret[0].([]types.KLine)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// QueryKLines indicates an expected call of QueryKLines.
func (mr *MockExchangeMockRecorder) QueryKLines(ctx, symbol, interval, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryKLines", reflect.TypeOf((*MockExchange)(nil).QueryKLines), ctx, symbol, interval, options)
}

// QueryMarkets mocks base method.
func (m *MockExchange) QueryMarkets(ctx context.Context) (types.MarketMap, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryMarkets", ctx)
	ret0, _ := ret[0].(types.MarketMap)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// QueryMarkets indicates an expected call of QueryMarkets.
func (mr *MockExchangeMockRecorder) QueryMarkets(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryMarkets", reflect.TypeOf((*MockExchange)(nil).QueryMarkets), ctx)
}

// QueryOpenOrders mocks base method.
func (m *MockExchange) QueryOpenOrders(ctx context.Context, symbol string) ([]types.Order, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryOpenOrders", ctx, symbol)
	ret0, _ := ret[0].([]types.Order)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// QueryOpenOrders indicates an expected call of QueryOpenOrders.
func (mr *MockExchangeMockRecorder) QueryOpenOrders(ctx, symbol any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryOpenOrders", reflect.TypeOf((*MockExchange)(nil).QueryOpenOrders), ctx, symbol)
}

// QueryTicker mocks base method.
func (m *MockExchange) QueryTicker(ctx context.Context, symbol string) (*types.Ticker, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryTicker", ctx, symbol)
	ret0, _ := ret[0].(*types.Ticker)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// QueryTicker indicates an expected call of QueryTicker.
func (mr *MockExchangeMockRecorder) QueryTicker(ctx, symbol any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryTicker", reflect.TypeOf((*MockExchange)(nil).QueryTicker), ctx, symbol)
}

// QueryTickers mocks base method.
func (m *MockExchange) QueryTickers(ctx context.Context, symbol ...string) (map[string]types.Ticker, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range symbol {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "QueryTickers", varargs...)
	ret0, _ := ret[0].(map[string]types.Ticker)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// QueryTickers indicates an expected call of QueryTickers.
func (mr *MockExchangeMockRecorder) QueryTickers(ctx any, symbol ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, symbol...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryTickers", reflect.TypeOf((*MockExchange)(nil).QueryTickers), varargs...)
}

// SubmitOrder mocks base method.
func (m *MockExchange) SubmitOrder(ctx context.Context, order types.SubmitOrder) (*types.Order, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SubmitOrder", ctx, order)
	ret0, _ := ret[0].(*types.Order)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SubmitOrder indicates an expected call of SubmitOrder.
func (mr *MockExchangeMockRecorder) SubmitOrder(ctx, order any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitOrder", reflect.TypeOf((*MockExchange)(nil).SubmitOrder), ctx, order)
}
