// Code generated by MockGen. DO NOT EDIT.
// Source: sync.go

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

import (
	reflect "reflect"

	v1 "github.com/baetyl/baetyl-go/v2/spec/v1"
	sync "github.com/baetyl/baetyl/v2/sync"
	gomock "github.com/golang/mock/gomock"
	routing "github.com/qiangxue/fasthttp-routing"
)

// MockSync is a mock of Sync interface.
type MockSync struct {
	ctrl     *gomock.Controller
	recorder *MockSyncMockRecorder
}

// MockSyncMockRecorder is the mock recorder for MockSync.
type MockSyncMockRecorder struct {
	mock *MockSync
}

// NewMockSync creates a new mock instance.
func NewMockSync(ctrl *gomock.Controller) *MockSync {
	mock := &MockSync{ctrl: ctrl}
	mock.recorder = &MockSyncMockRecorder{mock}
	return mock
}

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

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

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

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

// LinkState indicates an expected call of LinkState.
func (mr *MockSyncMockRecorder) LinkState(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LinkState", reflect.TypeOf((*MockSync)(nil).LinkState), ctx)
}

// Report mocks base method.
func (m *MockSync) Report(r v1.Report) (v1.Desire, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Report", r)
	ret0, _ := ret[0].(v1.Desire)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Report indicates an expected call of Report.
func (mr *MockSyncMockRecorder) Report(r interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Report", reflect.TypeOf((*MockSync)(nil).Report), r)
}

// Request mocks base method.
func (m *MockSync) Request(msg *v1.Message) (*v1.Message, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Request", msg)
	ret0, _ := ret[0].(*v1.Message)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Request indicates an expected call of Request.
func (mr *MockSyncMockRecorder) Request(msg interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Request", reflect.TypeOf((*MockSync)(nil).Request), msg)
}

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

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

// SyncApps mocks base method.
func (m *MockSync) SyncApps(infos []v1.AppInfo) (map[string]v1.Application, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SyncApps", infos)
	ret0, _ := ret[0].(map[string]v1.Application)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SyncApps indicates an expected call of SyncApps.
func (mr *MockSyncMockRecorder) SyncApps(infos interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SyncApps", reflect.TypeOf((*MockSync)(nil).SyncApps), infos)
}

// SyncDeviceModels mocks base method.
func (m *MockSync) SyncDeviceModels(device ...string) (map[string]sync.DeviceModel, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{}
	for _, a := range device {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SyncDeviceModels", varargs...)
	ret0, _ := ret[0].(map[string]sync.DeviceModel)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SyncDeviceModels indicates an expected call of SyncDeviceModels.
func (mr *MockSyncMockRecorder) SyncDeviceModels(device ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SyncDeviceModels", reflect.TypeOf((*MockSync)(nil).SyncDeviceModels), device...)
}

// SyncResource mocks base method.
func (m *MockSync) SyncResource(arg0 v1.AppInfo) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SyncResource", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SyncResource indicates an expected call of SyncResource.
func (mr *MockSyncMockRecorder) SyncResource(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SyncResource", reflect.TypeOf((*MockSync)(nil).SyncResource), arg0)
}
