// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/uber/cadence/common/persistence (interfaces: ExecutionStore,ShardStore,DomainStore,TaskStore,HistoryStore,ConfigStore)
//
// Generated by this command:
//
//	mockgen -package persistence -destination data_store_interfaces_mock.go -self_package github.com/uber/cadence/common/persistence github.com/uber/cadence/common/persistence ExecutionStore,ShardStore,DomainStore,TaskStore,HistoryStore,ConfigStore
//

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

import (
	context "context"
	reflect "reflect"

	gomock "go.uber.org/mock/gomock"
)

// MockExecutionStore is a mock of ExecutionStore interface.
type MockExecutionStore struct {
	ctrl     *gomock.Controller
	recorder *MockExecutionStoreMockRecorder
	isgomock struct{}
}

// MockExecutionStoreMockRecorder is the mock recorder for MockExecutionStore.
type MockExecutionStoreMockRecorder struct {
	mock *MockExecutionStore
}

// NewMockExecutionStore creates a new mock instance.
func NewMockExecutionStore(ctrl *gomock.Controller) *MockExecutionStore {
	mock := &MockExecutionStore{ctrl: ctrl}
	mock.recorder = &MockExecutionStoreMockRecorder{mock}
	return mock
}

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

// Close mocks base method.
func (m *MockExecutionStore) Close() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Close")
}

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

// CompleteHistoryTask mocks base method.
func (m *MockExecutionStore) CompleteHistoryTask(ctx context.Context, request *CompleteHistoryTaskRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CompleteHistoryTask", ctx, request)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ConflictResolveWorkflowExecution mocks base method.
func (m *MockExecutionStore) ConflictResolveWorkflowExecution(ctx context.Context, request *InternalConflictResolveWorkflowExecutionRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ConflictResolveWorkflowExecution", ctx, request)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// CreateFailoverMarkerTasks mocks base method.
func (m *MockExecutionStore) CreateFailoverMarkerTasks(ctx context.Context, request *CreateFailoverMarkersRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateFailoverMarkerTasks", ctx, request)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// CreateWorkflowExecution mocks base method.
func (m *MockExecutionStore) CreateWorkflowExecution(ctx context.Context, request *InternalCreateWorkflowExecutionRequest) (*CreateWorkflowExecutionResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateWorkflowExecution", ctx, request)
	ret0, _ := ret[0].(*CreateWorkflowExecutionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteActiveClusterSelectionPolicy mocks base method.
func (m *MockExecutionStore) DeleteActiveClusterSelectionPolicy(ctx context.Context, domainID, wfID, rID string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteActiveClusterSelectionPolicy", ctx, domainID, wfID, rID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteActiveClusterSelectionPolicy indicates an expected call of DeleteActiveClusterSelectionPolicy.
func (mr *MockExecutionStoreMockRecorder) DeleteActiveClusterSelectionPolicy(ctx, domainID, wfID, rID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteActiveClusterSelectionPolicy", reflect.TypeOf((*MockExecutionStore)(nil).DeleteActiveClusterSelectionPolicy), ctx, domainID, wfID, rID)
}

// DeleteCurrentWorkflowExecution mocks base method.
func (m *MockExecutionStore) DeleteCurrentWorkflowExecution(ctx context.Context, request *DeleteCurrentWorkflowExecutionRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteCurrentWorkflowExecution", ctx, request)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DeleteReplicationTaskFromDLQ mocks base method.
func (m *MockExecutionStore) DeleteReplicationTaskFromDLQ(ctx context.Context, request *DeleteReplicationTaskFromDLQRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteReplicationTaskFromDLQ", ctx, request)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DeleteWorkflowExecution mocks base method.
func (m *MockExecutionStore) DeleteWorkflowExecution(ctx context.Context, request *DeleteWorkflowExecutionRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteWorkflowExecution", ctx, request)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// GetActiveClusterSelectionPolicy mocks base method.
func (m *MockExecutionStore) GetActiveClusterSelectionPolicy(ctx context.Context, domainID, wfID, rID string) (*DataBlob, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetActiveClusterSelectionPolicy", ctx, domainID, wfID, rID)
	ret0, _ := ret[0].(*DataBlob)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetActiveClusterSelectionPolicy indicates an expected call of GetActiveClusterSelectionPolicy.
func (mr *MockExecutionStoreMockRecorder) GetActiveClusterSelectionPolicy(ctx, domainID, wfID, rID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetActiveClusterSelectionPolicy", reflect.TypeOf((*MockExecutionStore)(nil).GetActiveClusterSelectionPolicy), ctx, domainID, wfID, rID)
}

// GetCurrentExecution mocks base method.
func (m *MockExecutionStore) GetCurrentExecution(ctx context.Context, request *GetCurrentExecutionRequest) (*GetCurrentExecutionResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCurrentExecution", ctx, request)
	ret0, _ := ret[0].(*GetCurrentExecutionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetHistoryTasks mocks base method.
func (m *MockExecutionStore) GetHistoryTasks(ctx context.Context, request *GetHistoryTasksRequest) (*GetHistoryTasksResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetHistoryTasks", ctx, request)
	ret0, _ := ret[0].(*GetHistoryTasksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// GetReplicationDLQSize mocks base method.
func (m *MockExecutionStore) GetReplicationDLQSize(ctx context.Context, request *GetReplicationDLQSizeRequest) (*GetReplicationDLQSizeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetReplicationDLQSize", ctx, request)
	ret0, _ := ret[0].(*GetReplicationDLQSizeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetReplicationTasksFromDLQ mocks base method.
func (m *MockExecutionStore) GetReplicationTasksFromDLQ(ctx context.Context, request *GetReplicationTasksFromDLQRequest) (*GetHistoryTasksResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetReplicationTasksFromDLQ", ctx, request)
	ret0, _ := ret[0].(*GetHistoryTasksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// GetWorkflowExecution mocks base method.
func (m *MockExecutionStore) GetWorkflowExecution(ctx context.Context, request *InternalGetWorkflowExecutionRequest) (*InternalGetWorkflowExecutionResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkflowExecution", ctx, request)
	ret0, _ := ret[0].(*InternalGetWorkflowExecutionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// IsWorkflowExecutionExists mocks base method.
func (m *MockExecutionStore) IsWorkflowExecutionExists(ctx context.Context, request *IsWorkflowExecutionExistsRequest) (*IsWorkflowExecutionExistsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsWorkflowExecutionExists", ctx, request)
	ret0, _ := ret[0].(*IsWorkflowExecutionExistsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListConcreteExecutions mocks base method.
func (m *MockExecutionStore) ListConcreteExecutions(ctx context.Context, request *ListConcreteExecutionsRequest) (*InternalListConcreteExecutionsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListConcreteExecutions", ctx, request)
	ret0, _ := ret[0].(*InternalListConcreteExecutionsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListCurrentExecutions mocks base method.
func (m *MockExecutionStore) ListCurrentExecutions(ctx context.Context, request *ListCurrentExecutionsRequest) (*ListCurrentExecutionsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListCurrentExecutions", ctx, request)
	ret0, _ := ret[0].(*ListCurrentExecutionsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PutReplicationTaskToDLQ mocks base method.
func (m *MockExecutionStore) PutReplicationTaskToDLQ(ctx context.Context, request *InternalPutReplicationTaskToDLQRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutReplicationTaskToDLQ", ctx, request)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// RangeCompleteHistoryTask mocks base method.
func (m *MockExecutionStore) RangeCompleteHistoryTask(ctx context.Context, request *RangeCompleteHistoryTaskRequest) (*RangeCompleteHistoryTaskResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RangeCompleteHistoryTask", ctx, request)
	ret0, _ := ret[0].(*RangeCompleteHistoryTaskResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RangeDeleteReplicationTaskFromDLQ mocks base method.
func (m *MockExecutionStore) RangeDeleteReplicationTaskFromDLQ(ctx context.Context, request *RangeDeleteReplicationTaskFromDLQRequest) (*RangeDeleteReplicationTaskFromDLQResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RangeDeleteReplicationTaskFromDLQ", ctx, request)
	ret0, _ := ret[0].(*RangeDeleteReplicationTaskFromDLQResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateWorkflowExecution mocks base method.
func (m *MockExecutionStore) UpdateWorkflowExecution(ctx context.Context, request *InternalUpdateWorkflowExecutionRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateWorkflowExecution", ctx, request)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// MockShardStore is a mock of ShardStore interface.
type MockShardStore struct {
	ctrl     *gomock.Controller
	recorder *MockShardStoreMockRecorder
	isgomock struct{}
}

// MockShardStoreMockRecorder is the mock recorder for MockShardStore.
type MockShardStoreMockRecorder struct {
	mock *MockShardStore
}

// NewMockShardStore creates a new mock instance.
func NewMockShardStore(ctrl *gomock.Controller) *MockShardStore {
	mock := &MockShardStore{ctrl: ctrl}
	mock.recorder = &MockShardStoreMockRecorder{mock}
	return mock
}

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

// Close mocks base method.
func (m *MockShardStore) Close() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Close")
}

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

// CreateShard mocks base method.
func (m *MockShardStore) CreateShard(ctx context.Context, request *InternalCreateShardRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateShard", ctx, request)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

// GetShard mocks base method.
func (m *MockShardStore) GetShard(ctx context.Context, request *InternalGetShardRequest) (*InternalGetShardResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetShard", ctx, request)
	ret0, _ := ret[0].(*InternalGetShardResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateShard mocks base method.
func (m *MockShardStore) UpdateShard(ctx context.Context, request *InternalUpdateShardRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateShard", ctx, request)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// MockDomainStore is a mock of DomainStore interface.
type MockDomainStore struct {
	ctrl     *gomock.Controller
	recorder *MockDomainStoreMockRecorder
	isgomock struct{}
}

// MockDomainStoreMockRecorder is the mock recorder for MockDomainStore.
type MockDomainStoreMockRecorder struct {
	mock *MockDomainStore
}

// NewMockDomainStore creates a new mock instance.
func NewMockDomainStore(ctrl *gomock.Controller) *MockDomainStore {
	mock := &MockDomainStore{ctrl: ctrl}
	mock.recorder = &MockDomainStoreMockRecorder{mock}
	return mock
}

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

// Close mocks base method.
func (m *MockDomainStore) Close() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Close")
}

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

// CreateDomain mocks base method.
func (m *MockDomainStore) CreateDomain(ctx context.Context, request *InternalCreateDomainRequest) (*CreateDomainResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateDomain", ctx, request)
	ret0, _ := ret[0].(*CreateDomainResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteDomain mocks base method.
func (m *MockDomainStore) DeleteDomain(ctx context.Context, request *DeleteDomainRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteDomain", ctx, request)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DeleteDomainByName mocks base method.
func (m *MockDomainStore) DeleteDomainByName(ctx context.Context, request *DeleteDomainByNameRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteDomainByName", ctx, request)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// GetDomain mocks base method.
func (m *MockDomainStore) GetDomain(ctx context.Context, request *GetDomainRequest) (*InternalGetDomainResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDomain", ctx, request)
	ret0, _ := ret[0].(*InternalGetDomainResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

// ListDomains mocks base method.
func (m *MockDomainStore) ListDomains(ctx context.Context, request *ListDomainsRequest) (*InternalListDomainsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDomains", ctx, request)
	ret0, _ := ret[0].(*InternalListDomainsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateDomain mocks base method.
func (m *MockDomainStore) UpdateDomain(ctx context.Context, request *InternalUpdateDomainRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateDomain", ctx, request)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// MockTaskStore is a mock of TaskStore interface.
type MockTaskStore struct {
	ctrl     *gomock.Controller
	recorder *MockTaskStoreMockRecorder
	isgomock struct{}
}

// MockTaskStoreMockRecorder is the mock recorder for MockTaskStore.
type MockTaskStoreMockRecorder struct {
	mock *MockTaskStore
}

// NewMockTaskStore creates a new mock instance.
func NewMockTaskStore(ctrl *gomock.Controller) *MockTaskStore {
	mock := &MockTaskStore{ctrl: ctrl}
	mock.recorder = &MockTaskStoreMockRecorder{mock}
	return mock
}

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

// Close mocks base method.
func (m *MockTaskStore) Close() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Close")
}

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

// CompleteTask mocks base method.
func (m *MockTaskStore) CompleteTask(ctx context.Context, request *CompleteTaskRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CompleteTask", ctx, request)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// CompleteTasksLessThan mocks base method.
func (m *MockTaskStore) CompleteTasksLessThan(ctx context.Context, request *CompleteTasksLessThanRequest) (*CompleteTasksLessThanResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CompleteTasksLessThan", ctx, request)
	ret0, _ := ret[0].(*CompleteTasksLessThanResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateTasks mocks base method.
func (m *MockTaskStore) CreateTasks(ctx context.Context, request *CreateTasksRequest) (*CreateTasksResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTasks", ctx, request)
	ret0, _ := ret[0].(*CreateTasksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteTaskList mocks base method.
func (m *MockTaskStore) DeleteTaskList(ctx context.Context, request *DeleteTaskListRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTaskList", ctx, request)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

// GetOrphanTasks mocks base method.
func (m *MockTaskStore) GetOrphanTasks(ctx context.Context, request *GetOrphanTasksRequest) (*GetOrphanTasksResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOrphanTasks", ctx, request)
	ret0, _ := ret[0].(*GetOrphanTasksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetTaskList mocks base method.
func (m *MockTaskStore) GetTaskList(ctx context.Context, request *GetTaskListRequest) (*GetTaskListResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTaskList", ctx, request)
	ret0, _ := ret[0].(*GetTaskListResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetTaskListSize mocks base method.
func (m *MockTaskStore) GetTaskListSize(ctx context.Context, request *GetTaskListSizeRequest) (*GetTaskListSizeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTaskListSize", ctx, request)
	ret0, _ := ret[0].(*GetTaskListSizeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetTasks mocks base method.
func (m *MockTaskStore) GetTasks(ctx context.Context, request *GetTasksRequest) (*GetTasksResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTasks", ctx, request)
	ret0, _ := ret[0].(*GetTasksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// LeaseTaskList mocks base method.
func (m *MockTaskStore) LeaseTaskList(ctx context.Context, request *LeaseTaskListRequest) (*LeaseTaskListResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LeaseTaskList", ctx, request)
	ret0, _ := ret[0].(*LeaseTaskListResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListTaskList mocks base method.
func (m *MockTaskStore) ListTaskList(ctx context.Context, request *ListTaskListRequest) (*ListTaskListResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTaskList", ctx, request)
	ret0, _ := ret[0].(*ListTaskListResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateTaskList mocks base method.
func (m *MockTaskStore) UpdateTaskList(ctx context.Context, request *UpdateTaskListRequest) (*UpdateTaskListResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTaskList", ctx, request)
	ret0, _ := ret[0].(*UpdateTaskListResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockHistoryStore is a mock of HistoryStore interface.
type MockHistoryStore struct {
	ctrl     *gomock.Controller
	recorder *MockHistoryStoreMockRecorder
	isgomock struct{}
}

// MockHistoryStoreMockRecorder is the mock recorder for MockHistoryStore.
type MockHistoryStoreMockRecorder struct {
	mock *MockHistoryStore
}

// NewMockHistoryStore creates a new mock instance.
func NewMockHistoryStore(ctrl *gomock.Controller) *MockHistoryStore {
	mock := &MockHistoryStore{ctrl: ctrl}
	mock.recorder = &MockHistoryStoreMockRecorder{mock}
	return mock
}

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

// AppendHistoryNodes mocks base method.
func (m *MockHistoryStore) AppendHistoryNodes(ctx context.Context, request *InternalAppendHistoryNodesRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AppendHistoryNodes", ctx, request)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// Close mocks base method.
func (m *MockHistoryStore) Close() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Close")
}

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

// DeleteHistoryBranch mocks base method.
func (m *MockHistoryStore) DeleteHistoryBranch(ctx context.Context, request *InternalDeleteHistoryBranchRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteHistoryBranch", ctx, request)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ForkHistoryBranch mocks base method.
func (m *MockHistoryStore) ForkHistoryBranch(ctx context.Context, request *InternalForkHistoryBranchRequest) (*InternalForkHistoryBranchResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ForkHistoryBranch", ctx, request)
	ret0, _ := ret[0].(*InternalForkHistoryBranchResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetAllHistoryTreeBranches mocks base method.
func (m *MockHistoryStore) GetAllHistoryTreeBranches(ctx context.Context, request *GetAllHistoryTreeBranchesRequest) (*GetAllHistoryTreeBranchesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAllHistoryTreeBranches", ctx, request)
	ret0, _ := ret[0].(*GetAllHistoryTreeBranchesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetHistoryTree mocks base method.
func (m *MockHistoryStore) GetHistoryTree(ctx context.Context, request *InternalGetHistoryTreeRequest) (*InternalGetHistoryTreeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetHistoryTree", ctx, request)
	ret0, _ := ret[0].(*InternalGetHistoryTreeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// ReadHistoryBranch mocks base method.
func (m *MockHistoryStore) ReadHistoryBranch(ctx context.Context, request *InternalReadHistoryBranchRequest) (*InternalReadHistoryBranchResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadHistoryBranch", ctx, request)
	ret0, _ := ret[0].(*InternalReadHistoryBranchResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockConfigStore is a mock of ConfigStore interface.
type MockConfigStore struct {
	ctrl     *gomock.Controller
	recorder *MockConfigStoreMockRecorder
	isgomock struct{}
}

// MockConfigStoreMockRecorder is the mock recorder for MockConfigStore.
type MockConfigStoreMockRecorder struct {
	mock *MockConfigStore
}

// NewMockConfigStore creates a new mock instance.
func NewMockConfigStore(ctrl *gomock.Controller) *MockConfigStore {
	mock := &MockConfigStore{ctrl: ctrl}
	mock.recorder = &MockConfigStoreMockRecorder{mock}
	return mock
}

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

// Close mocks base method.
func (m *MockConfigStore) Close() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Close")
}

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

// FetchConfig mocks base method.
func (m *MockConfigStore) FetchConfig(ctx context.Context, configType ConfigType) (*InternalConfigStoreEntry, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FetchConfig", ctx, configType)
	ret0, _ := ret[0].(*InternalConfigStoreEntry)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateConfig mocks base method.
func (m *MockConfigStore) UpdateConfig(ctx context.Context, value *InternalConfigStoreEntry) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateConfig", ctx, value)
	ret0, _ := ret[0].(error)
	return ret0
}

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