reference_mock.go

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

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

import (
	businesslogic "github.com/ProximaB/das/businesslogic"
	gomock "github.com/golang/mock/gomock"
	reflect "reflect"
)

// MockICountryRepository is a mock of ICountryRepository interface
type MockICountryRepository struct {
	ctrl     *gomock.Controller
	recorder *MockICountryRepositoryMockRecorder
}

// MockICountryRepositoryMockRecorder is the mock recorder for MockICountryRepository
type MockICountryRepositoryMockRecorder struct {
	mock *MockICountryRepository
}

// NewMockICountryRepository creates a new mock instance
func NewMockICountryRepository(ctrl *gomock.Controller) *MockICountryRepository {
	mock := &MockICountryRepository{ctrl: ctrl}
	mock.recorder = &MockICountryRepositoryMockRecorder{mock}
	return mock
}

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

// CreateCountry mocks base method
func (m *MockICountryRepository) CreateCountry(country *businesslogic.Country) error {
	ret := m.ctrl.Call(m, "CreateCountry", country)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateCountry indicates an expected call of CreateCountry
func (mr *MockICountryRepositoryMockRecorder) CreateCountry(country interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCountry", reflect.TypeOf((*MockICountryRepository)(nil).CreateCountry), country)
}

// SearchCountry mocks base method
func (m *MockICountryRepository) SearchCountry(criteria businesslogic.SearchCountryCriteria) ([]businesslogic.Country, error) {
	ret := m.ctrl.Call(m, "SearchCountry", criteria)
	ret0, _ := ret[0].([]businesslogic.Country)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SearchCountry indicates an expected call of SearchCountry
func (mr *MockICountryRepositoryMockRecorder) SearchCountry(criteria interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchCountry", reflect.TypeOf((*MockICountryRepository)(nil).SearchCountry), criteria)
}

// DeleteCountry mocks base method
func (m *MockICountryRepository) DeleteCountry(country businesslogic.Country) error {
	ret := m.ctrl.Call(m, "DeleteCountry", country)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteCountry indicates an expected call of DeleteCountry
func (mr *MockICountryRepositoryMockRecorder) DeleteCountry(country interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCountry", reflect.TypeOf((*MockICountryRepository)(nil).DeleteCountry), country)
}

// UpdateCountry mocks base method
func (m *MockICountryRepository) UpdateCountry(country businesslogic.Country) error {
	ret := m.ctrl.Call(m, "UpdateCountry", country)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateCountry indicates an expected call of UpdateCountry
func (mr *MockICountryRepositoryMockRecorder) UpdateCountry(country interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateCountry", reflect.TypeOf((*MockICountryRepository)(nil).UpdateCountry), country)
}

// MockIStateRepository is a mock of IStateRepository interface
type MockIStateRepository struct {
	ctrl     *gomock.Controller
	recorder *MockIStateRepositoryMockRecorder
}

// MockIStateRepositoryMockRecorder is the mock recorder for MockIStateRepository
type MockIStateRepositoryMockRecorder struct {
	mock *MockIStateRepository
}

// NewMockIStateRepository creates a new mock instance
func NewMockIStateRepository(ctrl *gomock.Controller) *MockIStateRepository {
	mock := &MockIStateRepository{ctrl: ctrl}
	mock.recorder = &MockIStateRepositoryMockRecorder{mock}
	return mock
}

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

// CreateState mocks base method
func (m *MockIStateRepository) CreateState(state *businesslogic.State) error {
	ret := m.ctrl.Call(m, "CreateState", state)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateState indicates an expected call of CreateState
func (mr *MockIStateRepositoryMockRecorder) CreateState(state interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateState", reflect.TypeOf((*MockIStateRepository)(nil).CreateState), state)
}

// SearchState mocks base method
func (m *MockIStateRepository) SearchState(criteria businesslogic.SearchStateCriteria) ([]businesslogic.State, error) {
	ret := m.ctrl.Call(m, "SearchState", criteria)
	ret0, _ := ret[0].([]businesslogic.State)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SearchState indicates an expected call of SearchState
func (mr *MockIStateRepositoryMockRecorder) SearchState(criteria interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchState", reflect.TypeOf((*MockIStateRepository)(nil).SearchState), criteria)
}

// UpdateState mocks base method
func (m *MockIStateRepository) UpdateState(state businesslogic.State) error {
	ret := m.ctrl.Call(m, "UpdateState", state)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateState indicates an expected call of UpdateState
func (mr *MockIStateRepositoryMockRecorder) UpdateState(state interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateState", reflect.TypeOf((*MockIStateRepository)(nil).UpdateState), state)
}

// DeleteState mocks base method
func (m *MockIStateRepository) DeleteState(state businesslogic.State) error {
	ret := m.ctrl.Call(m, "DeleteState", state)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteState indicates an expected call of DeleteState
func (mr *MockIStateRepositoryMockRecorder) DeleteState(state interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteState", reflect.TypeOf((*MockIStateRepository)(nil).DeleteState), state)
}

// MockICityRepository is a mock of ICityRepository interface
type MockICityRepository struct {
	ctrl     *gomock.Controller
	recorder *MockICityRepositoryMockRecorder
}

// MockICityRepositoryMockRecorder is the mock recorder for MockICityRepository
type MockICityRepositoryMockRecorder struct {
	mock *MockICityRepository
}

// NewMockICityRepository creates a new mock instance
func NewMockICityRepository(ctrl *gomock.Controller) *MockICityRepository {
	mock := &MockICityRepository{ctrl: ctrl}
	mock.recorder = &MockICityRepositoryMockRecorder{mock}
	return mock
}

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

// CreateCity mocks base method
func (m *MockICityRepository) CreateCity(city *businesslogic.City) error {
	ret := m.ctrl.Call(m, "CreateCity", city)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateCity indicates an expected call of CreateCity
func (mr *MockICityRepositoryMockRecorder) CreateCity(city interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCity", reflect.TypeOf((*MockICityRepository)(nil).CreateCity), city)
}

// SearchCity mocks base method
func (m *MockICityRepository) SearchCity(criteria businesslogic.SearchCityCriteria) ([]businesslogic.City, error) {
	ret := m.ctrl.Call(m, "SearchCity", criteria)
	ret0, _ := ret[0].([]businesslogic.City)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SearchCity indicates an expected call of SearchCity
func (mr *MockICityRepositoryMockRecorder) SearchCity(criteria interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchCity", reflect.TypeOf((*MockICityRepository)(nil).SearchCity), criteria)
}

// UpdateCity mocks base method
func (m *MockICityRepository) UpdateCity(city businesslogic.City) error {
	ret := m.ctrl.Call(m, "UpdateCity", city)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateCity indicates an expected call of UpdateCity
func (mr *MockICityRepositoryMockRecorder) UpdateCity(city interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateCity", reflect.TypeOf((*MockICityRepository)(nil).UpdateCity), city)
}

// DeleteCity mocks base method
func (m *MockICityRepository) DeleteCity(city businesslogic.City) error {
	ret := m.ctrl.Call(m, "DeleteCity", city)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteCity indicates an expected call of DeleteCity
func (mr *MockICityRepositoryMockRecorder) DeleteCity(city interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCity", reflect.TypeOf((*MockICityRepository)(nil).DeleteCity), city)
}

// MockIFederationRepository is a mock of IFederationRepository interface
type MockIFederationRepository struct {
	ctrl     *gomock.Controller
	recorder *MockIFederationRepositoryMockRecorder
}

// MockIFederationRepositoryMockRecorder is the mock recorder for MockIFederationRepository
type MockIFederationRepositoryMockRecorder struct {
	mock *MockIFederationRepository
}

// NewMockIFederationRepository creates a new mock instance
func NewMockIFederationRepository(ctrl *gomock.Controller) *MockIFederationRepository {
	mock := &MockIFederationRepository{ctrl: ctrl}
	mock.recorder = &MockIFederationRepositoryMockRecorder{mock}
	return mock
}

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

// CreateFederation mocks base method
func (m *MockIFederationRepository) CreateFederation(federation *businesslogic.Federation) error {
	ret := m.ctrl.Call(m, "CreateFederation", federation)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateFederation indicates an expected call of CreateFederation
func (mr *MockIFederationRepositoryMockRecorder) CreateFederation(federation interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFederation", reflect.TypeOf((*MockIFederationRepository)(nil).CreateFederation), federation)
}

// SearchFederation mocks base method
func (m *MockIFederationRepository) SearchFederation(criteria businesslogic.SearchFederationCriteria) ([]businesslogic.Federation, error) {
	ret := m.ctrl.Call(m, "SearchFederation", criteria)
	ret0, _ := ret[0].([]businesslogic.Federation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SearchFederation indicates an expected call of SearchFederation
func (mr *MockIFederationRepositoryMockRecorder) SearchFederation(criteria interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchFederation", reflect.TypeOf((*MockIFederationRepository)(nil).SearchFederation), criteria)
}

// UpdateFederation mocks base method
func (m *MockIFederationRepository) UpdateFederation(federation businesslogic.Federation) error {
	ret := m.ctrl.Call(m, "UpdateFederation", federation)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateFederation indicates an expected call of UpdateFederation
func (mr *MockIFederationRepositoryMockRecorder) UpdateFederation(federation interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateFederation", reflect.TypeOf((*MockIFederationRepository)(nil).UpdateFederation), federation)
}

// DeleteFederation mocks base method
func (m *MockIFederationRepository) DeleteFederation(federation businesslogic.Federation) error {
	ret := m.ctrl.Call(m, "DeleteFederation", federation)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteFederation indicates an expected call of DeleteFederation
func (mr *MockIFederationRepositoryMockRecorder) DeleteFederation(federation interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFederation", reflect.TypeOf((*MockIFederationRepository)(nil).DeleteFederation), federation)
}

// MockIDivisionRepository is a mock of IDivisionRepository interface
type MockIDivisionRepository struct {
	ctrl     *gomock.Controller
	recorder *MockIDivisionRepositoryMockRecorder
}

// MockIDivisionRepositoryMockRecorder is the mock recorder for MockIDivisionRepository
type MockIDivisionRepositoryMockRecorder struct {
	mock *MockIDivisionRepository
}

// NewMockIDivisionRepository creates a new mock instance
func NewMockIDivisionRepository(ctrl *gomock.Controller) *MockIDivisionRepository {
	mock := &MockIDivisionRepository{ctrl: ctrl}
	mock.recorder = &MockIDivisionRepositoryMockRecorder{mock}
	return mock
}

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

// CreateDivision mocks base method
func (m *MockIDivisionRepository) CreateDivision(division *businesslogic.Division) error {
	ret := m.ctrl.Call(m, "CreateDivision", division)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateDivision indicates an expected call of CreateDivision
func (mr *MockIDivisionRepositoryMockRecorder) CreateDivision(division interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDivision", reflect.TypeOf((*MockIDivisionRepository)(nil).CreateDivision), division)
}

// SearchDivision mocks base method
func (m *MockIDivisionRepository) SearchDivision(criteria businesslogic.SearchDivisionCriteria) ([]businesslogic.Division, error) {
	ret := m.ctrl.Call(m, "SearchDivision", criteria)
	ret0, _ := ret[0].([]businesslogic.Division)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SearchDivision indicates an expected call of SearchDivision
func (mr *MockIDivisionRepositoryMockRecorder) SearchDivision(criteria interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchDivision", reflect.TypeOf((*MockIDivisionRepository)(nil).SearchDivision), criteria)
}

// UpdateDivision mocks base method
func (m *MockIDivisionRepository) UpdateDivision(division businesslogic.Division) error {
	ret := m.ctrl.Call(m, "UpdateDivision", division)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateDivision indicates an expected call of UpdateDivision
func (mr *MockIDivisionRepositoryMockRecorder) UpdateDivision(division interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDivision", reflect.TypeOf((*MockIDivisionRepository)(nil).UpdateDivision), division)
}

// DeleteDivision mocks base method
func (m *MockIDivisionRepository) DeleteDivision(division businesslogic.Division) error {
	ret := m.ctrl.Call(m, "DeleteDivision", division)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteDivision indicates an expected call of DeleteDivision
func (mr *MockIDivisionRepositoryMockRecorder) DeleteDivision(division interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDivision", reflect.TypeOf((*MockIDivisionRepository)(nil).DeleteDivision), division)
}

// MockIAgeRepository is a mock of IAgeRepository interface
type MockIAgeRepository struct {
	ctrl     *gomock.Controller
	recorder *MockIAgeRepositoryMockRecorder
}

// MockIAgeRepositoryMockRecorder is the mock recorder for MockIAgeRepository
type MockIAgeRepositoryMockRecorder struct {
	mock *MockIAgeRepository
}

// NewMockIAgeRepository creates a new mock instance
func NewMockIAgeRepository(ctrl *gomock.Controller) *MockIAgeRepository {
	mock := &MockIAgeRepository{ctrl: ctrl}
	mock.recorder = &MockIAgeRepositoryMockRecorder{mock}
	return mock
}

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

// CreateAge mocks base method
func (m *MockIAgeRepository) CreateAge(age *businesslogic.Age) error {
	ret := m.ctrl.Call(m, "CreateAge", age)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateAge indicates an expected call of CreateAge
func (mr *MockIAgeRepositoryMockRecorder) CreateAge(age interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAge", reflect.TypeOf((*MockIAgeRepository)(nil).CreateAge), age)
}

// SearchAge mocks base method
func (m *MockIAgeRepository) SearchAge(criteria businesslogic.SearchAgeCriteria) ([]businesslogic.Age, error) {
	ret := m.ctrl.Call(m, "SearchAge", criteria)
	ret0, _ := ret[0].([]businesslogic.Age)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SearchAge indicates an expected call of SearchAge
func (mr *MockIAgeRepositoryMockRecorder) SearchAge(criteria interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchAge", reflect.TypeOf((*MockIAgeRepository)(nil).SearchAge), criteria)
}

// UpdateAge mocks base method
func (m *MockIAgeRepository) UpdateAge(age businesslogic.Age) error {
	ret := m.ctrl.Call(m, "UpdateAge", age)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateAge indicates an expected call of UpdateAge
func (mr *MockIAgeRepositoryMockRecorder) UpdateAge(age interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAge", reflect.TypeOf((*MockIAgeRepository)(nil).UpdateAge), age)
}

// DeleteAge mocks base method
func (m *MockIAgeRepository) DeleteAge(age businesslogic.Age) error {
	ret := m.ctrl.Call(m, "DeleteAge", age)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteAge indicates an expected call of DeleteAge
func (mr *MockIAgeRepositoryMockRecorder) DeleteAge(age interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAge", reflect.TypeOf((*MockIAgeRepository)(nil).DeleteAge), age)
}

// MockIProficiencyRepository is a mock of IProficiencyRepository interface
type MockIProficiencyRepository struct {
	ctrl     *gomock.Controller
	recorder *MockIProficiencyRepositoryMockRecorder
}

// MockIProficiencyRepositoryMockRecorder is the mock recorder for MockIProficiencyRepository
type MockIProficiencyRepositoryMockRecorder struct {
	mock *MockIProficiencyRepository
}

// NewMockIProficiencyRepository creates a new mock instance
func NewMockIProficiencyRepository(ctrl *gomock.Controller) *MockIProficiencyRepository {
	mock := &MockIProficiencyRepository{ctrl: ctrl}
	mock.recorder = &MockIProficiencyRepositoryMockRecorder{mock}
	return mock
}

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

// SearchProficiency mocks base method
func (m *MockIProficiencyRepository) SearchProficiency(criteria businesslogic.SearchProficiencyCriteria) ([]businesslogic.Proficiency, error) {
	ret := m.ctrl.Call(m, "SearchProficiency", criteria)
	ret0, _ := ret[0].([]businesslogic.Proficiency)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SearchProficiency indicates an expected call of SearchProficiency
func (mr *MockIProficiencyRepositoryMockRecorder) SearchProficiency(criteria interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchProficiency", reflect.TypeOf((*MockIProficiencyRepository)(nil).SearchProficiency), criteria)
}

// CreateProficiency mocks base method
func (m *MockIProficiencyRepository) CreateProficiency(proficiency *businesslogic.Proficiency) error {
	ret := m.ctrl.Call(m, "CreateProficiency", proficiency)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateProficiency indicates an expected call of CreateProficiency
func (mr *MockIProficiencyRepositoryMockRecorder) CreateProficiency(proficiency interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateProficiency", reflect.TypeOf((*MockIProficiencyRepository)(nil).CreateProficiency), proficiency)
}

// UpdateProficiency mocks base method
func (m *MockIProficiencyRepository) UpdateProficiency(proficiency businesslogic.Proficiency) error {
	ret := m.ctrl.Call(m, "UpdateProficiency", proficiency)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateProficiency indicates an expected call of UpdateProficiency
func (mr *MockIProficiencyRepositoryMockRecorder) UpdateProficiency(proficiency interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateProficiency", reflect.TypeOf((*MockIProficiencyRepository)(nil).UpdateProficiency), proficiency)
}

// DeleteProficiency mocks base method
func (m *MockIProficiencyRepository) DeleteProficiency(proficiency businesslogic.Proficiency) error {
	ret := m.ctrl.Call(m, "DeleteProficiency", proficiency)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteProficiency indicates an expected call of DeleteProficiency
func (mr *MockIProficiencyRepositoryMockRecorder) DeleteProficiency(proficiency interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteProficiency", reflect.TypeOf((*MockIProficiencyRepository)(nil).DeleteProficiency), proficiency)
}

// MockIStyleRepository is a mock of IStyleRepository interface
type MockIStyleRepository struct {
	ctrl     *gomock.Controller
	recorder *MockIStyleRepositoryMockRecorder
}

// MockIStyleRepositoryMockRecorder is the mock recorder for MockIStyleRepository
type MockIStyleRepositoryMockRecorder struct {
	mock *MockIStyleRepository
}

// NewMockIStyleRepository creates a new mock instance
func NewMockIStyleRepository(ctrl *gomock.Controller) *MockIStyleRepository {
	mock := &MockIStyleRepository{ctrl: ctrl}
	mock.recorder = &MockIStyleRepositoryMockRecorder{mock}
	return mock
}

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

// CreateStyle mocks base method
func (m *MockIStyleRepository) CreateStyle(style *businesslogic.Style) error {
	ret := m.ctrl.Call(m, "CreateStyle", style)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateStyle indicates an expected call of CreateStyle
func (mr *MockIStyleRepositoryMockRecorder) CreateStyle(style interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateStyle", reflect.TypeOf((*MockIStyleRepository)(nil).CreateStyle), style)
}

// SearchStyle mocks base method
func (m *MockIStyleRepository) SearchStyle(criteria businesslogic.SearchStyleCriteria) ([]businesslogic.Style, error) {
	ret := m.ctrl.Call(m, "SearchStyle", criteria)
	ret0, _ := ret[0].([]businesslogic.Style)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SearchStyle indicates an expected call of SearchStyle
func (mr *MockIStyleRepositoryMockRecorder) SearchStyle(criteria interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchStyle", reflect.TypeOf((*MockIStyleRepository)(nil).SearchStyle), criteria)
}

// UpdateStyle mocks base method
func (m *MockIStyleRepository) UpdateStyle(style businesslogic.Style) error {
	ret := m.ctrl.Call(m, "UpdateStyle", style)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateStyle indicates an expected call of UpdateStyle
func (mr *MockIStyleRepositoryMockRecorder) UpdateStyle(style interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateStyle", reflect.TypeOf((*MockIStyleRepository)(nil).UpdateStyle), style)
}

// DeleteStyle mocks base method
func (m *MockIStyleRepository) DeleteStyle(style businesslogic.Style) error {
	ret := m.ctrl.Call(m, "DeleteStyle", style)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteStyle indicates an expected call of DeleteStyle
func (mr *MockIStyleRepositoryMockRecorder) DeleteStyle(style interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteStyle", reflect.TypeOf((*MockIStyleRepository)(nil).DeleteStyle), style)
}

// MockIDanceRepository is a mock of IDanceRepository interface
type MockIDanceRepository struct {
	ctrl     *gomock.Controller
	recorder *MockIDanceRepositoryMockRecorder
}

// MockIDanceRepositoryMockRecorder is the mock recorder for MockIDanceRepository
type MockIDanceRepositoryMockRecorder struct {
	mock *MockIDanceRepository
}

// NewMockIDanceRepository creates a new mock instance
func NewMockIDanceRepository(ctrl *gomock.Controller) *MockIDanceRepository {
	mock := &MockIDanceRepository{ctrl: ctrl}
	mock.recorder = &MockIDanceRepositoryMockRecorder{mock}
	return mock
}

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

// CreateDance mocks base method
func (m *MockIDanceRepository) CreateDance(dance *businesslogic.Dance) error {
	ret := m.ctrl.Call(m, "CreateDance", dance)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateDance indicates an expected call of CreateDance
func (mr *MockIDanceRepositoryMockRecorder) CreateDance(dance interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDance", reflect.TypeOf((*MockIDanceRepository)(nil).CreateDance), dance)
}

// SearchDance mocks base method
func (m *MockIDanceRepository) SearchDance(criteria businesslogic.SearchDanceCriteria) ([]businesslogic.Dance, error) {
	ret := m.ctrl.Call(m, "SearchDance", criteria)
	ret0, _ := ret[0].([]businesslogic.Dance)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SearchDance indicates an expected call of SearchDance
func (mr *MockIDanceRepositoryMockRecorder) SearchDance(criteria interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchDance", reflect.TypeOf((*MockIDanceRepository)(nil).SearchDance), criteria)
}

// UpdateDance mocks base method
func (m *MockIDanceRepository) UpdateDance(dance businesslogic.Dance) error {
	ret := m.ctrl.Call(m, "UpdateDance", dance)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateDance indicates an expected call of UpdateDance
func (mr *MockIDanceRepositoryMockRecorder) UpdateDance(dance interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDance", reflect.TypeOf((*MockIDanceRepository)(nil).UpdateDance), dance)
}

// DeleteDance mocks base method
func (m *MockIDanceRepository) DeleteDance(dance businesslogic.Dance) error {
	ret := m.ctrl.Call(m, "DeleteDance", dance)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteDance indicates an expected call of DeleteDance
func (mr *MockIDanceRepositoryMockRecorder) DeleteDance(dance interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDance", reflect.TypeOf((*MockIDanceRepository)(nil).DeleteDance), dance)
}

// MockISchoolRepository is a mock of ISchoolRepository interface
type MockISchoolRepository struct {
	ctrl     *gomock.Controller
	recorder *MockISchoolRepositoryMockRecorder
}

// MockISchoolRepositoryMockRecorder is the mock recorder for MockISchoolRepository
type MockISchoolRepositoryMockRecorder struct {
	mock *MockISchoolRepository
}

// NewMockISchoolRepository creates a new mock instance
func NewMockISchoolRepository(ctrl *gomock.Controller) *MockISchoolRepository {
	mock := &MockISchoolRepository{ctrl: ctrl}
	mock.recorder = &MockISchoolRepositoryMockRecorder{mock}
	return mock
}

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

// CreateSchool mocks base method
func (m *MockISchoolRepository) CreateSchool(school *businesslogic.School) error {
	ret := m.ctrl.Call(m, "CreateSchool", school)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateSchool indicates an expected call of CreateSchool
func (mr *MockISchoolRepositoryMockRecorder) CreateSchool(school interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSchool", reflect.TypeOf((*MockISchoolRepository)(nil).CreateSchool), school)
}

// SearchSchool mocks base method
func (m *MockISchoolRepository) SearchSchool(criteria businesslogic.SearchSchoolCriteria) ([]businesslogic.School, error) {
	ret := m.ctrl.Call(m, "SearchSchool", criteria)
	ret0, _ := ret[0].([]businesslogic.School)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SearchSchool indicates an expected call of SearchSchool
func (mr *MockISchoolRepositoryMockRecorder) SearchSchool(criteria interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchSchool", reflect.TypeOf((*MockISchoolRepository)(nil).SearchSchool), criteria)
}

// UpdateSchool mocks base method
func (m *MockISchoolRepository) UpdateSchool(school businesslogic.School) error {
	ret := m.ctrl.Call(m, "UpdateSchool", school)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateSchool indicates an expected call of UpdateSchool
func (mr *MockISchoolRepositoryMockRecorder) UpdateSchool(school interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSchool", reflect.TypeOf((*MockISchoolRepository)(nil).UpdateSchool), school)
}

// DeleteSchool mocks base method
func (m *MockISchoolRepository) DeleteSchool(school businesslogic.School) error {
	ret := m.ctrl.Call(m, "DeleteSchool", school)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteSchool indicates an expected call of DeleteSchool
func (mr *MockISchoolRepositoryMockRecorder) DeleteSchool(school interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSchool", reflect.TypeOf((*MockISchoolRepository)(nil).DeleteSchool), school)
}

// MockIStudioRepository is a mock of IStudioRepository interface
type MockIStudioRepository struct {
	ctrl     *gomock.Controller
	recorder *MockIStudioRepositoryMockRecorder
}

// MockIStudioRepositoryMockRecorder is the mock recorder for MockIStudioRepository
type MockIStudioRepositoryMockRecorder struct {
	mock *MockIStudioRepository
}

// NewMockIStudioRepository creates a new mock instance
func NewMockIStudioRepository(ctrl *gomock.Controller) *MockIStudioRepository {
	mock := &MockIStudioRepository{ctrl: ctrl}
	mock.recorder = &MockIStudioRepositoryMockRecorder{mock}
	return mock
}

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

// CreateStudio mocks base method
func (m *MockIStudioRepository) CreateStudio(studio *businesslogic.Studio) error {
	ret := m.ctrl.Call(m, "CreateStudio", studio)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateStudio indicates an expected call of CreateStudio
func (mr *MockIStudioRepositoryMockRecorder) CreateStudio(studio interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateStudio", reflect.TypeOf((*MockIStudioRepository)(nil).CreateStudio), studio)
}

// SearchStudio mocks base method
func (m *MockIStudioRepository) SearchStudio(criteria businesslogic.SearchStudioCriteria) ([]businesslogic.Studio, error) {
	ret := m.ctrl.Call(m, "SearchStudio", criteria)
	ret0, _ := ret[0].([]businesslogic.Studio)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SearchStudio indicates an expected call of SearchStudio
func (mr *MockIStudioRepositoryMockRecorder) SearchStudio(criteria interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchStudio", reflect.TypeOf((*MockIStudioRepository)(nil).SearchStudio), criteria)
}

// DeleteStudio mocks base method
func (m *MockIStudioRepository) DeleteStudio(studio businesslogic.Studio) error {
	ret := m.ctrl.Call(m, "DeleteStudio", studio)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteStudio indicates an expected call of DeleteStudio
func (mr *MockIStudioRepositoryMockRecorder) DeleteStudio(studio interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteStudio", reflect.TypeOf((*MockIStudioRepository)(nil).DeleteStudio), studio)
}

// UpdateStudio mocks base method
func (m *MockIStudioRepository) UpdateStudio(studio businesslogic.Studio) error {
	ret := m.ctrl.Call(m, "UpdateStudio", studio)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateStudio indicates an expected call of UpdateStudio
func (mr *MockIStudioRepositoryMockRecorder) UpdateStudio(studio interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateStudio", reflect.TypeOf((*MockIStudioRepository)(nil).UpdateStudio), studio)
}

// MockIGenderRepository is a mock of IGenderRepository interface
type MockIGenderRepository struct {
	ctrl     *gomock.Controller
	recorder *MockIGenderRepositoryMockRecorder
}

// MockIGenderRepositoryMockRecorder is the mock recorder for MockIGenderRepository
type MockIGenderRepositoryMockRecorder struct {
	mock *MockIGenderRepository
}

// NewMockIGenderRepository creates a new mock instance
func NewMockIGenderRepository(ctrl *gomock.Controller) *MockIGenderRepository {
	mock := &MockIGenderRepository{ctrl: ctrl}
	mock.recorder = &MockIGenderRepositoryMockRecorder{mock}
	return mock
}

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

// GetAllGenders mocks base method
func (m *MockIGenderRepository) GetAllGenders() ([]businesslogic.Gender, error) {
	ret := m.ctrl.Call(m, "GetAllGenders")
	ret0, _ := ret[0].([]businesslogic.Gender)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAllGenders indicates an expected call of GetAllGenders
func (mr *MockIGenderRepositoryMockRecorder) GetAllGenders() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllGenders", reflect.TypeOf((*MockIGenderRepository)(nil).GetAllGenders))
}