// Code generated by MockGen. DO NOT EDIT.
// Source: ../interfaces/object_type_access.go
//
// Generated by this command:
//
//	mockgen -source ../interfaces/object_type_access.go -destination ../interfaces/mock/mock_object_type_access.go
//

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

import (
	interfaces "bkn-backend/interfaces"
	context "context"
	sql "database/sql"
	reflect "reflect"

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

// MockObjectTypeAccess is a mock of ObjectTypeAccess interface.
type MockObjectTypeAccess struct {
	ctrl     *gomock.Controller
	recorder *MockObjectTypeAccessMockRecorder
	isgomock struct{}
}

// MockObjectTypeAccessMockRecorder is the mock recorder for MockObjectTypeAccess.
type MockObjectTypeAccessMockRecorder struct {
	mock *MockObjectTypeAccess
}

// NewMockObjectTypeAccess creates a new mock instance.
func NewMockObjectTypeAccess(ctrl *gomock.Controller) *MockObjectTypeAccess {
	mock := &MockObjectTypeAccess{ctrl: ctrl}
	mock.recorder = &MockObjectTypeAccessMockRecorder{mock}
	return mock
}

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

// CheckObjectTypeExistByID mocks base method.
func (m *MockObjectTypeAccess) CheckObjectTypeExistByID(ctx context.Context, knID, branch, otID string) (string, bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CheckObjectTypeExistByID", ctx, knID, branch, otID)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(bool)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CheckObjectTypeExistByID indicates an expected call of CheckObjectTypeExistByID.
func (mr *MockObjectTypeAccessMockRecorder) CheckObjectTypeExistByID(ctx, knID, branch, otID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckObjectTypeExistByID", reflect.TypeOf((*MockObjectTypeAccess)(nil).CheckObjectTypeExistByID), ctx, knID, branch, otID)
}

// CheckObjectTypeExistByName mocks base method.
func (m *MockObjectTypeAccess) CheckObjectTypeExistByName(ctx context.Context, knID, branch, otName string) (string, bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CheckObjectTypeExistByName", ctx, knID, branch, otName)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(bool)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CheckObjectTypeExistByName indicates an expected call of CheckObjectTypeExistByName.
func (mr *MockObjectTypeAccessMockRecorder) CheckObjectTypeExistByName(ctx, knID, branch, otName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckObjectTypeExistByName", reflect.TypeOf((*MockObjectTypeAccess)(nil).CheckObjectTypeExistByName), ctx, knID, branch, otName)
}

// CreateObjectType mocks base method.
func (m *MockObjectTypeAccess) CreateObjectType(ctx context.Context, tx *sql.Tx, objectType *interfaces.ObjectType) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateObjectType", ctx, tx, objectType)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateObjectType indicates an expected call of CreateObjectType.
func (mr *MockObjectTypeAccessMockRecorder) CreateObjectType(ctx, tx, objectType any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateObjectType", reflect.TypeOf((*MockObjectTypeAccess)(nil).CreateObjectType), ctx, tx, objectType)
}

// CreateObjectTypeStatus mocks base method.
func (m *MockObjectTypeAccess) CreateObjectTypeStatus(ctx context.Context, tx *sql.Tx, objectType *interfaces.ObjectType) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateObjectTypeStatus", ctx, tx, objectType)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateObjectTypeStatus indicates an expected call of CreateObjectTypeStatus.
func (mr *MockObjectTypeAccessMockRecorder) CreateObjectTypeStatus(ctx, tx, objectType any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateObjectTypeStatus", reflect.TypeOf((*MockObjectTypeAccess)(nil).CreateObjectTypeStatus), ctx, tx, objectType)
}

// DeleteObjectTypeStatusByIDs mocks base method.
func (m *MockObjectTypeAccess) DeleteObjectTypeStatusByIDs(ctx context.Context, tx *sql.Tx, knID, branch string, otIDs []string) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteObjectTypeStatusByIDs", ctx, tx, knID, branch, otIDs)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteObjectTypeStatusByIDs indicates an expected call of DeleteObjectTypeStatusByIDs.
func (mr *MockObjectTypeAccessMockRecorder) DeleteObjectTypeStatusByIDs(ctx, tx, knID, branch, otIDs any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteObjectTypeStatusByIDs", reflect.TypeOf((*MockObjectTypeAccess)(nil).DeleteObjectTypeStatusByIDs), ctx, tx, knID, branch, otIDs)
}

// DeleteObjectTypeStatusByKnID mocks base method.
func (m *MockObjectTypeAccess) DeleteObjectTypeStatusByKnID(ctx context.Context, tx *sql.Tx, knID, branch string) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteObjectTypeStatusByKnID", ctx, tx, knID, branch)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteObjectTypeStatusByKnID indicates an expected call of DeleteObjectTypeStatusByKnID.
func (mr *MockObjectTypeAccessMockRecorder) DeleteObjectTypeStatusByKnID(ctx, tx, knID, branch any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteObjectTypeStatusByKnID", reflect.TypeOf((*MockObjectTypeAccess)(nil).DeleteObjectTypeStatusByKnID), ctx, tx, knID, branch)
}

// DeleteObjectTypesByIDs mocks base method.
func (m *MockObjectTypeAccess) DeleteObjectTypesByIDs(ctx context.Context, tx *sql.Tx, knID, branch string, otIDs []string) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteObjectTypesByIDs", ctx, tx, knID, branch, otIDs)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteObjectTypesByIDs indicates an expected call of DeleteObjectTypesByIDs.
func (mr *MockObjectTypeAccessMockRecorder) DeleteObjectTypesByIDs(ctx, tx, knID, branch, otIDs any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteObjectTypesByIDs", reflect.TypeOf((*MockObjectTypeAccess)(nil).DeleteObjectTypesByIDs), ctx, tx, knID, branch, otIDs)
}

// DeleteObjectTypesByKnID mocks base method.
func (m *MockObjectTypeAccess) DeleteObjectTypesByKnID(ctx context.Context, tx *sql.Tx, knID, branch string) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteObjectTypesByKnID", ctx, tx, knID, branch)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteObjectTypesByKnID indicates an expected call of DeleteObjectTypesByKnID.
func (mr *MockObjectTypeAccessMockRecorder) DeleteObjectTypesByKnID(ctx, tx, knID, branch any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteObjectTypesByKnID", reflect.TypeOf((*MockObjectTypeAccess)(nil).DeleteObjectTypesByKnID), ctx, tx, knID, branch)
}

// GetAllObjectTypesByKnID mocks base method.
func (m *MockObjectTypeAccess) GetAllObjectTypesByKnID(ctx context.Context, knID, branch string) (map[string]*interfaces.ObjectType, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAllObjectTypesByKnID", ctx, knID, branch)
	ret0, _ := ret[0].(map[string]*interfaces.ObjectType)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAllObjectTypesByKnID indicates an expected call of GetAllObjectTypesByKnID.
func (mr *MockObjectTypeAccessMockRecorder) GetAllObjectTypesByKnID(ctx, knID, branch any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllObjectTypesByKnID", reflect.TypeOf((*MockObjectTypeAccess)(nil).GetAllObjectTypesByKnID), ctx, knID, branch)
}

// GetObjectTypeByID mocks base method.
func (m *MockObjectTypeAccess) GetObjectTypeByID(ctx context.Context, tx *sql.Tx, knID, branch, otID string) (*interfaces.ObjectType, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetObjectTypeByID", ctx, tx, knID, branch, otID)
	ret0, _ := ret[0].(*interfaces.ObjectType)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetObjectTypeByID indicates an expected call of GetObjectTypeByID.
func (mr *MockObjectTypeAccessMockRecorder) GetObjectTypeByID(ctx, tx, knID, branch, otID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectTypeByID", reflect.TypeOf((*MockObjectTypeAccess)(nil).GetObjectTypeByID), ctx, tx, knID, branch, otID)
}

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

// GetObjectTypeIDsByKnID indicates an expected call of GetObjectTypeIDsByKnID.
func (mr *MockObjectTypeAccessMockRecorder) GetObjectTypeIDsByKnID(ctx, knID, branch any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectTypeIDsByKnID", reflect.TypeOf((*MockObjectTypeAccess)(nil).GetObjectTypeIDsByKnID), ctx, knID, branch)
}

// GetObjectTypesByIDs mocks base method.
func (m *MockObjectTypeAccess) GetObjectTypesByIDs(ctx context.Context, tx *sql.Tx, knID, branch string, otIDs []string) ([]*interfaces.ObjectType, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetObjectTypesByIDs", ctx, tx, knID, branch, otIDs)
	ret0, _ := ret[0].([]*interfaces.ObjectType)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetObjectTypesByIDs indicates an expected call of GetObjectTypesByIDs.
func (mr *MockObjectTypeAccessMockRecorder) GetObjectTypesByIDs(ctx, tx, knID, branch, otIDs any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectTypesByIDs", reflect.TypeOf((*MockObjectTypeAccess)(nil).GetObjectTypesByIDs), ctx, tx, knID, branch, otIDs)
}

// GetObjectTypesTotal mocks base method.
func (m *MockObjectTypeAccess) GetObjectTypesTotal(ctx context.Context, query interfaces.ObjectTypesQueryParams) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetObjectTypesTotal", ctx, query)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListObjectTypes mocks base method.
func (m *MockObjectTypeAccess) ListObjectTypes(ctx context.Context, tx *sql.Tx, query interfaces.ObjectTypesQueryParams) ([]*interfaces.ObjectType, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListObjectTypes", ctx, tx, query)
	ret0, _ := ret[0].([]*interfaces.ObjectType)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListObjectTypes indicates an expected call of ListObjectTypes.
func (mr *MockObjectTypeAccessMockRecorder) ListObjectTypes(ctx, tx, query any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectTypes", reflect.TypeOf((*MockObjectTypeAccess)(nil).ListObjectTypes), ctx, tx, query)
}

// UpdateDataProperties mocks base method.
func (m *MockObjectTypeAccess) UpdateDataProperties(ctx context.Context, tx *sql.Tx, objectType *interfaces.ObjectType) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateDataProperties", ctx, tx, objectType)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateDataProperties indicates an expected call of UpdateDataProperties.
func (mr *MockObjectTypeAccessMockRecorder) UpdateDataProperties(ctx, tx, objectType any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDataProperties", reflect.TypeOf((*MockObjectTypeAccess)(nil).UpdateDataProperties), ctx, tx, objectType)
}

// UpdateObjectType mocks base method.
func (m *MockObjectTypeAccess) UpdateObjectType(ctx context.Context, tx *sql.Tx, objectType *interfaces.ObjectType) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateObjectType", ctx, tx, objectType)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateObjectType indicates an expected call of UpdateObjectType.
func (mr *MockObjectTypeAccessMockRecorder) UpdateObjectType(ctx, tx, objectType any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateObjectType", reflect.TypeOf((*MockObjectTypeAccess)(nil).UpdateObjectType), ctx, tx, objectType)
}

// UpdateObjectTypeStatus mocks base method.
func (m *MockObjectTypeAccess) UpdateObjectTypeStatus(ctx context.Context, tx *sql.Tx, knID, branch, otID string, otStatus interfaces.ObjectTypeStatus) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateObjectTypeStatus", ctx, tx, knID, branch, otID, otStatus)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateObjectTypeStatus indicates an expected call of UpdateObjectTypeStatus.
func (mr *MockObjectTypeAccessMockRecorder) UpdateObjectTypeStatus(ctx, tx, knID, branch, otID, otStatus any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateObjectTypeStatus", reflect.TypeOf((*MockObjectTypeAccess)(nil).UpdateObjectTypeStatus), ctx, tx, knID, branch, otID, otStatus)
}
