// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/ChainSafe/gossamer/dot/state (interfaces: Telemetry,BlockStateDatabase,Observer)
//
// Generated by this command:
//
//	mockgen -destination=mocks_test.go -package state . Telemetry,BlockStateDatabase,Observer
//

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

import (
	json "encoding/json"
	reflect "reflect"

	database "github.com/ChainSafe/gossamer/internal/database"
	gomock "go.uber.org/mock/gomock"
)

// MockTelemetry is a mock of Telemetry interface.
type MockTelemetry struct {
	ctrl     *gomock.Controller
	recorder *MockTelemetryMockRecorder
	isgomock struct{}
}

// MockTelemetryMockRecorder is the mock recorder for MockTelemetry.
type MockTelemetryMockRecorder struct {
	mock *MockTelemetry
}

// NewMockTelemetry creates a new mock instance.
func NewMockTelemetry(ctrl *gomock.Controller) *MockTelemetry {
	mock := &MockTelemetry{ctrl: ctrl}
	mock.recorder = &MockTelemetryMockRecorder{mock}
	return mock
}

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

// SendMessage mocks base method.
func (m *MockTelemetry) SendMessage(msg json.Marshaler) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SendMessage", msg)
}

// SendMessage indicates an expected call of SendMessage.
func (mr *MockTelemetryMockRecorder) SendMessage(msg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMessage", reflect.TypeOf((*MockTelemetry)(nil).SendMessage), msg)
}

// MockBlockStateDatabase is a mock of BlockStateDatabase interface.
type MockBlockStateDatabase struct {
	ctrl     *gomock.Controller
	recorder *MockBlockStateDatabaseMockRecorder
	isgomock struct{}
}

// MockBlockStateDatabaseMockRecorder is the mock recorder for MockBlockStateDatabase.
type MockBlockStateDatabaseMockRecorder struct {
	mock *MockBlockStateDatabase
}

// NewMockBlockStateDatabase creates a new mock instance.
func NewMockBlockStateDatabase(ctrl *gomock.Controller) *MockBlockStateDatabase {
	mock := &MockBlockStateDatabase{ctrl: ctrl}
	mock.recorder = &MockBlockStateDatabaseMockRecorder{mock}
	return mock
}

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

// Del mocks base method.
func (m *MockBlockStateDatabase) Del(key []byte) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Del", key)
	ret0, _ := ret[0].(error)
	return ret0
}

// Del indicates an expected call of Del.
func (mr *MockBlockStateDatabaseMockRecorder) Del(key any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Del", reflect.TypeOf((*MockBlockStateDatabase)(nil).Del), key)
}

// Get mocks base method.
func (m *MockBlockStateDatabase) Get(key []byte) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", key)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Get indicates an expected call of Get.
func (mr *MockBlockStateDatabaseMockRecorder) Get(key any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockBlockStateDatabase)(nil).Get), key)
}

// Has mocks base method.
func (m *MockBlockStateDatabase) Has(key []byte) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Has", key)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Has indicates an expected call of Has.
func (mr *MockBlockStateDatabaseMockRecorder) Has(key any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Has", reflect.TypeOf((*MockBlockStateDatabase)(nil).Has), key)
}

// NewBatch mocks base method.
func (m *MockBlockStateDatabase) NewBatch() database.Batch {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewBatch")
	ret0, _ := ret[0].(database.Batch)
	return ret0
}

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

// Put mocks base method.
func (m *MockBlockStateDatabase) Put(key, value []byte) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Put", key, value)
	ret0, _ := ret[0].(error)
	return ret0
}

// Put indicates an expected call of Put.
func (mr *MockBlockStateDatabaseMockRecorder) Put(key, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Put", reflect.TypeOf((*MockBlockStateDatabase)(nil).Put), key, value)
}

// MockObserver is a mock of Observer interface.
type MockObserver struct {
	ctrl     *gomock.Controller
	recorder *MockObserverMockRecorder
	isgomock struct{}
}

// MockObserverMockRecorder is the mock recorder for MockObserver.
type MockObserverMockRecorder struct {
	mock *MockObserver
}

// NewMockObserver creates a new mock instance.
func NewMockObserver(ctrl *gomock.Controller) *MockObserver {
	mock := &MockObserver{ctrl: ctrl}
	mock.recorder = &MockObserverMockRecorder{mock}
	return mock
}

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

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

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

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

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

// Update mocks base method.
func (m *MockObserver) Update(result *SubscriptionResult) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Update", result)
}

// Update indicates an expected call of Update.
func (mr *MockObserverMockRecorder) Update(result any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockObserver)(nil).Update), result)
}
