// Code generated by MockGen. DO NOT EDIT.
// Source: pkg/api/v2/changefeed.go

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

import (
	context "context"
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"
	v2 "github.com/pingcap/ticdc/api/v2"
	v20 "github.com/pingcap/ticdc/pkg/api/v2"
)

// MockChangefeedsGetter is a mock of ChangefeedsGetter interface.
type MockChangefeedsGetter struct {
	ctrl     *gomock.Controller
	recorder *MockChangefeedsGetterMockRecorder
}

// MockChangefeedsGetterMockRecorder is the mock recorder for MockChangefeedsGetter.
type MockChangefeedsGetterMockRecorder struct {
	mock *MockChangefeedsGetter
}

// NewMockChangefeedsGetter creates a new mock instance.
func NewMockChangefeedsGetter(ctrl *gomock.Controller) *MockChangefeedsGetter {
	mock := &MockChangefeedsGetter{ctrl: ctrl}
	mock.recorder = &MockChangefeedsGetterMockRecorder{mock}
	return mock
}

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

// Changefeeds mocks base method.
func (m *MockChangefeedsGetter) Changefeeds() v20.ChangefeedInterface {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Changefeeds")
	ret0, _ := ret[0].(v20.ChangefeedInterface)
	return ret0
}

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

// MockChangefeedInterface is a mock of ChangefeedInterface interface.
type MockChangefeedInterface struct {
	ctrl     *gomock.Controller
	recorder *MockChangefeedInterfaceMockRecorder
}

// MockChangefeedInterfaceMockRecorder is the mock recorder for MockChangefeedInterface.
type MockChangefeedInterfaceMockRecorder struct {
	mock *MockChangefeedInterface
}

// NewMockChangefeedInterface creates a new mock instance.
func NewMockChangefeedInterface(ctrl *gomock.Controller) *MockChangefeedInterface {
	mock := &MockChangefeedInterface{ctrl: ctrl}
	mock.recorder = &MockChangefeedInterfaceMockRecorder{mock}
	return mock
}

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

// Create mocks base method.
func (m *MockChangefeedInterface) Create(ctx context.Context, cfg *v2.ChangefeedConfig, keyspace string) (*v2.ChangeFeedInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Create", ctx, cfg, keyspace)
	ret0, _ := ret[0].(*v2.ChangeFeedInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Create indicates an expected call of Create.
func (mr *MockChangefeedInterfaceMockRecorder) Create(ctx, cfg, keyspace interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockChangefeedInterface)(nil).Create), ctx, cfg, keyspace)
}

// Delete mocks base method.
func (m *MockChangefeedInterface) Delete(ctx context.Context, keyspace, name string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", ctx, keyspace, name)
	ret0, _ := ret[0].(error)
	return ret0
}

// Delete indicates an expected call of Delete.
func (mr *MockChangefeedInterfaceMockRecorder) Delete(ctx, keyspace, name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockChangefeedInterface)(nil).Delete), ctx, keyspace, name)
}

// Get mocks base method.
func (m *MockChangefeedInterface) Get(ctx context.Context, keyspace, name string) (*v2.ChangeFeedInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", ctx, keyspace, name)
	ret0, _ := ret[0].(*v2.ChangeFeedInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Get indicates an expected call of Get.
func (mr *MockChangefeedInterfaceMockRecorder) Get(ctx, keyspace, name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockChangefeedInterface)(nil).Get), ctx, keyspace, name)
}

// GetAllTables mocks base method.
func (m *MockChangefeedInterface) GetAllTables(ctx context.Context, cfg *v2.VerifyTableConfig, keyspace string) (*v2.Tables, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAllTables", ctx, cfg, keyspace)
	ret0, _ := ret[0].(*v2.Tables)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAllTables indicates an expected call of GetAllTables.
func (mr *MockChangefeedInterfaceMockRecorder) GetAllTables(ctx, cfg, keyspace interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllTables", reflect.TypeOf((*MockChangefeedInterface)(nil).GetAllTables), ctx, cfg, keyspace)
}

// List mocks base method.
func (m *MockChangefeedInterface) List(ctx context.Context, keyspace, state string) ([]v2.ChangefeedCommonInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "List", ctx, keyspace, state)
	ret0, _ := ret[0].([]v2.ChangefeedCommonInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// List indicates an expected call of List.
func (mr *MockChangefeedInterfaceMockRecorder) List(ctx, keyspace, state interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockChangefeedInterface)(nil).List), ctx, keyspace, state)
}

// MergeTable mocks base method.
func (m *MockChangefeedInterface) MergeTable(ctx context.Context, keyspace, name string, tableID, mode int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MergeTable", ctx, keyspace, name, tableID, mode)
	ret0, _ := ret[0].(error)
	return ret0
}

// MergeTable indicates an expected call of MergeTable.
func (mr *MockChangefeedInterfaceMockRecorder) MergeTable(ctx, keyspace, name, tableID, mode interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MergeTable", reflect.TypeOf((*MockChangefeedInterface)(nil).MergeTable), ctx, keyspace, name, tableID, mode)
}

// MoveSplitTable mocks base method.
func (m *MockChangefeedInterface) MoveSplitTable(ctx context.Context, keyspace, name string, tableID int64, targetNode string, mode int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MoveSplitTable", ctx, keyspace, name, tableID, targetNode, mode)
	ret0, _ := ret[0].(error)
	return ret0
}

// MoveSplitTable indicates an expected call of MoveSplitTable.
func (mr *MockChangefeedInterfaceMockRecorder) MoveSplitTable(ctx, keyspace, name, tableID, targetNode, mode interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MoveSplitTable", reflect.TypeOf((*MockChangefeedInterface)(nil).MoveSplitTable), ctx, keyspace, name, tableID, targetNode, mode)
}

// MoveTable mocks base method.
func (m *MockChangefeedInterface) MoveTable(ctx context.Context, keyspace, name string, tableID int64, targetNode string, mode int64, wait bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MoveTable", ctx, keyspace, name, tableID, targetNode, mode, wait)
	ret0, _ := ret[0].(error)
	return ret0
}

// MoveTable indicates an expected call of MoveTable.
func (mr *MockChangefeedInterfaceMockRecorder) MoveTable(ctx, keyspace, name, tableID, targetNode, mode, wait interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MoveTable", reflect.TypeOf((*MockChangefeedInterface)(nil).MoveTable), ctx, keyspace, name, tableID, targetNode, mode, wait)
}

// Pause mocks base method.
func (m *MockChangefeedInterface) Pause(ctx context.Context, keyspace, name string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Pause", ctx, keyspace, name)
	ret0, _ := ret[0].(error)
	return ret0
}

// Pause indicates an expected call of Pause.
func (mr *MockChangefeedInterfaceMockRecorder) Pause(ctx, keyspace, name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Pause", reflect.TypeOf((*MockChangefeedInterface)(nil).Pause), ctx, keyspace, name)
}

// Resume mocks base method.
func (m *MockChangefeedInterface) Resume(ctx context.Context, cfg *v2.ResumeChangefeedConfig, keyspace, name string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Resume", ctx, cfg, keyspace, name)
	ret0, _ := ret[0].(error)
	return ret0
}

// Resume indicates an expected call of Resume.
func (mr *MockChangefeedInterfaceMockRecorder) Resume(ctx, cfg, keyspace, name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Resume", reflect.TypeOf((*MockChangefeedInterface)(nil).Resume), ctx, cfg, keyspace, name)
}

// SplitTableByRegionCount mocks base method.
func (m *MockChangefeedInterface) SplitTableByRegionCount(ctx context.Context, keyspace, name string, tableID, mode int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SplitTableByRegionCount", ctx, keyspace, name, tableID, mode)
	ret0, _ := ret[0].(error)
	return ret0
}

// SplitTableByRegionCount indicates an expected call of SplitTableByRegionCount.
func (mr *MockChangefeedInterfaceMockRecorder) SplitTableByRegionCount(ctx, keyspace, name, tableID, mode interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SplitTableByRegionCount", reflect.TypeOf((*MockChangefeedInterface)(nil).SplitTableByRegionCount), ctx, keyspace, name, tableID, mode)
}

// Update mocks base method.
func (m *MockChangefeedInterface) Update(ctx context.Context, cfg *v2.ChangefeedConfig, keyspace, name string) (*v2.ChangeFeedInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Update", ctx, cfg, keyspace, name)
	ret0, _ := ret[0].(*v2.ChangeFeedInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Update indicates an expected call of Update.
func (mr *MockChangefeedInterfaceMockRecorder) Update(ctx, cfg, keyspace, name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockChangefeedInterface)(nil).Update), ctx, cfg, keyspace, name)
}

// VerifyTable mocks base method.
func (m *MockChangefeedInterface) VerifyTable(ctx context.Context, cfg *v2.VerifyTableConfig, keyspace string) (*v2.Tables, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VerifyTable", ctx, cfg, keyspace)
	ret0, _ := ret[0].(*v2.Tables)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// VerifyTable indicates an expected call of VerifyTable.
func (mr *MockChangefeedInterfaceMockRecorder) VerifyTable(ctx, cfg, keyspace interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyTable", reflect.TypeOf((*MockChangefeedInterface)(nil).VerifyTable), ctx, cfg, keyspace)
}