// Code generated by MockGen. DO NOT EDIT.
// Source: ../interfaces/action_type_access.go
//
// Generated by this command:
//
//	mockgen -source ../interfaces/action_type_access.go -destination ../interfaces/mock/mock_action_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"
)

// MockActionTypeAccess is a mock of ActionTypeAccess interface.
type MockActionTypeAccess struct {
	ctrl     *gomock.Controller
	recorder *MockActionTypeAccessMockRecorder
	isgomock struct{}
}

// MockActionTypeAccessMockRecorder is the mock recorder for MockActionTypeAccess.
type MockActionTypeAccessMockRecorder struct {
	mock *MockActionTypeAccess
}

// NewMockActionTypeAccess creates a new mock instance.
func NewMockActionTypeAccess(ctrl *gomock.Controller) *MockActionTypeAccess {
	mock := &MockActionTypeAccess{ctrl: ctrl}
	mock.recorder = &MockActionTypeAccessMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

// CreateActionType indicates an expected call of CreateActionType.
func (mr *MockActionTypeAccessMockRecorder) CreateActionType(ctx, tx, actionType any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateActionType", reflect.TypeOf((*MockActionTypeAccess)(nil).CreateActionType), ctx, tx, actionType)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// UpdateActionType indicates an expected call of UpdateActionType.
func (mr *MockActionTypeAccessMockRecorder) UpdateActionType(ctx, tx, actionType any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateActionType", reflect.TypeOf((*MockActionTypeAccess)(nil).UpdateActionType), ctx, tx, actionType)
}
