func (mr *MockIDistributedEnforcerMockRecorder) GetFilteredPolicy(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFilteredPolicy", reflect.TypeOf((*MockIDistributedEnforcer)(nil).GetFilteredPolicy), varargs...)
}
GetFilteredPolicy indicates an expected call of GetFilteredPolicy.
package mocks
import (
	reflect "reflect"
	govaluate "github.com/Knetic/govaluate"
	effector "github.com/casbin/casbin/v2/effector"
	model "github.com/casbin/casbin/v2/model"
	persist "github.com/casbin/casbin/v2/persist"
	rbac "github.com/casbin/casbin/v2/rbac"
	gomock "github.com/golang/mock/gomock"
)
type MockIDistributedEnforcer struct {
	ctrl     *gomock.Controller
	recorder *MockIDistributedEnforcerMockRecorder
}
type MockIDistributedEnforcerMockRecorder struct {
	mock *MockIDistributedEnforcer
}
func NewMockIDistributedEnforcer(ctrl *gomock.Controller) *MockIDistributedEnforcer {
	mock := &MockIDistributedEnforcer{ctrl: ctrl}
	mock.recorder = &MockIDistributedEnforcerMockRecorder{mock}
	return mock
}
func (m *MockIDistributedEnforcer) EXPECT() *MockIDistributedEnforcerMockRecorder {
	return m.recorder
}
func (m *MockIDistributedEnforcer) AddFunction(arg0 string, arg1 govaluate.ExpressionFunction) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddFunction", arg0, arg1)
}
func (mr *MockIDistributedEnforcerMockRecorder) AddFunction(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddFunction", reflect.TypeOf((*MockIDistributedEnforcer)(nil).AddFunction), arg0, arg1)
}
func (m *MockIDistributedEnforcer) AddGroupingPolicies(arg0 [][]string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddGroupingPolicies", arg0)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockIDistributedEnforcerMockRecorder) AddGroupingPolicies(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddGroupingPolicies", reflect.TypeOf((*MockIDistributedEnforcer)(nil).AddGroupingPolicies), arg0)
}
func (m *MockIDistributedEnforcer) AddGroupingPolicy(arg0 ...interface{}) (bool, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{}
	for _, a := range arg0 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AddGroupingPolicy", varargs...)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockIDistributedEnforcerMockRecorder) AddGroupingPolicy(arg0 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddGroupingPolicy", reflect.TypeOf((*MockIDistributedEnforcer)(nil).AddGroupingPolicy), arg0...)
}
func (m *MockIDistributedEnforcer) AddNamedGroupingPolicies(arg0 string, arg1 [][]string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddNamedGroupingPolicies", arg0, arg1)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockIDistributedEnforcerMockRecorder) AddNamedGroupingPolicies(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddNamedGroupingPolicies", reflect.TypeOf((*MockIDistributedEnforcer)(nil).AddNamedGroupingPolicies), arg0, arg1)
}
func (m *MockIDistributedEnforcer) AddNamedGroupingPolicy(arg0 string, arg1 ...interface{}) (bool, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AddNamedGroupingPolicy", varargs...)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockIDistributedEnforcerMockRecorder) AddNamedGroupingPolicy(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddNamedGroupingPolicy", reflect.TypeOf((*MockIDistributedEnforcer)(nil).AddNamedGroupingPolicy), varargs...)
}
func (m *MockIDistributedEnforcer) AddNamedPolicies(arg0 string, arg1 [][]string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddNamedPolicies", arg0, arg1)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockIDistributedEnforcerMockRecorder) AddNamedPolicies(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddNamedPolicies", reflect.TypeOf((*MockIDistributedEnforcer)(nil).AddNamedPolicies), arg0, arg1)
}
func (m *MockIDistributedEnforcer) AddNamedPolicy(arg0 string, arg1 ...interface{}) (bool, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AddNamedPolicy", varargs...)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockIDistributedEnforcerMockRecorder) AddNamedPolicy(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddNamedPolicy", reflect.TypeOf((*MockIDistributedEnforcer)(nil).AddNamedPolicy), varargs...)
}
func (m *MockIDistributedEnforcer) AddPermissionForUser(arg0 string, arg1 ...string) (bool, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AddPermissionForUser", varargs...)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockIDistributedEnforcerMockRecorder) AddPermissionForUser(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddPermissionForUser", reflect.TypeOf((*MockIDistributedEnforcer)(nil).AddPermissionForUser), varargs...)
}
func (m *MockIDistributedEnforcer) AddPolicies(arg0 [][]string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddPolicies", arg0)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockIDistributedEnforcerMockRecorder) AddPolicies(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddPolicies", reflect.TypeOf((*MockIDistributedEnforcer)(nil).AddPolicies), arg0)
}
func (m *MockIDistributedEnforcer) AddPoliciesSelf(arg0 func() bool, arg1, arg2 string, arg3 [][]string) ([][]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddPoliciesSelf", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].([][]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockIDistributedEnforcerMockRecorder) AddPoliciesSelf(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddPoliciesSelf", reflect.TypeOf((*MockIDistributedEnforcer)(nil).AddPoliciesSelf), arg0, arg1, arg2, arg3)
}
func (m *MockIDistributedEnforcer) AddPolicy(arg0 ...interface{}) (bool, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{}
	for _, a := range arg0 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AddPolicy", varargs...)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockIDistributedEnforcerMockRecorder) AddPolicy(arg0 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddPolicy", reflect.TypeOf((*MockIDistributedEnforcer)(nil).AddPolicy), arg0...)
}
func (m *MockIDistributedEnforcer) AddRoleForUser(arg0, arg1 string, arg2 ...string) (bool, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AddRoleForUser", varargs...)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockIDistributedEnforcerMockRecorder) AddRoleForUser(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRoleForUser", reflect.TypeOf((*MockIDistributedEnforcer)(nil).AddRoleForUser), varargs...)
}
func (m *MockIDistributedEnforcer) AddRoleForUserInDomain(arg0, arg1, arg2 string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddRoleForUserInDomain", arg0, arg1, arg2)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockIDistributedEnforcerMockRecorder) AddRoleForUserInDomain(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRoleForUserInDomain", reflect.TypeOf((*MockIDistributedEnforcer)(nil).AddRoleForUserInDomain), arg0, arg1, arg2)
}
func (m *MockIDistributedEnforcer) BatchEnforce(arg0 [][]interface{}) ([]bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BatchEnforce", arg0)
	ret0, _ := ret[0].([]bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockIDistributedEnforcerMockRecorder) BatchEnforce(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchEnforce", reflect.TypeOf((*MockIDistributedEnforcer)(nil).BatchEnforce), arg0)
}
func (m *MockIDistributedEnforcer) BatchEnforceWithMatcher(arg0 string, arg1 [][]interface{}) ([]bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BatchEnforceWithMatcher", arg0, arg1)
	ret0, _ := ret[0].([]bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockIDistributedEnforcerMockRecorder) BatchEnforceWithMatcher(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchEnforceWithMatcher", reflect.TypeOf((*MockIDistributedEnforcer)(nil).BatchEnforceWithMatcher), arg0, arg1)
}
func (m *MockIDistributedEnforcer) BuildRoleLinks() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BuildRoleLinks")
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockIDistributedEnforcerMockRecorder) BuildRoleLinks() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BuildRoleLinks", reflect.TypeOf((*MockIDistributedEnforcer)(nil).BuildRoleLinks))
}
func (m *MockIDistributedEnforcer) ClearPolicy() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ClearPolicy")
}
func (mr *MockIDistributedEnforcerMockRecorder) ClearPolicy() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClearPolicy", reflect.TypeOf((*MockIDistributedEnforcer)(nil).ClearPolicy))
}
func (m *MockIDistributedEnforcer) ClearPolicySelf(arg0 func() bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClearPolicySelf", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockIDistributedEnforcerMockRecorder) ClearPolicySelf(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClearPolicySelf", reflect.TypeOf((*MockIDistributedEnforcer)(nil).ClearPolicySelf), arg0)
}
func (m *MockIDistributedEnforcer) DeletePermission(arg0 ...string) (bool, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{}
	for _, a := range arg0 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeletePermission", varargs...)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockIDistributedEnforcerMockRecorder) DeletePermission(arg0 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePermission", reflect.TypeOf((*MockIDistributedEnforcer)(nil).DeletePermission), arg0...)
}
func (m *MockIDistributedEnforcer) DeletePermissionForUser(arg0 string, arg1 ...string) (bool, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeletePermissionForUser", varargs...)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockIDistributedEnforcerMockRecorder) DeletePermissionForUser(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePermissionForUser", reflect.TypeOf((*MockIDistributedEnforcer)(nil).DeletePermissionForUser), varargs...)
}
func (m *MockIDistributedEnforcer) DeletePermissionsForUser(arg0 string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeletePermissionsForUser", arg0)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockIDistributedEnforcerMockRecorder) DeletePermissionsForUser(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePermissionsForUser", reflect.TypeOf((*MockIDistributedEnforcer)(nil).DeletePermissionsForUser), arg0)
}
func (m *MockIDistributedEnforcer) DeleteRole(arg0 string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteRole", arg0)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockIDistributedEnforcerMockRecorder) DeleteRole(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRole", reflect.TypeOf((*MockIDistributedEnforcer)(nil).DeleteRole), arg0)
}
func (m *MockIDistributedEnforcer) DeleteRoleForUser(arg0, arg1 string, arg2 ...string) (bool, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteRoleForUser", varargs...)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockIDistributedEnforcerMockRecorder) DeleteRoleForUser(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRoleForUser", reflect.TypeOf((*MockIDistributedEnforcer)(nil).DeleteRoleForUser), varargs...)
}
func (m *MockIDistributedEnforcer) DeleteRoleForUserInDomain(arg0, arg1, arg2 string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteRoleForUserInDomain", arg0, arg1, arg2)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockIDistributedEnforcerMockRecorder) DeleteRoleForUserInDomain(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRoleForUserInDomain", reflect.TypeOf((*MockIDistributedEnforcer)(nil).DeleteRoleForUserInDomain), arg0, arg1, arg2)
}
func (m *MockIDistributedEnforcer) DeleteRolesForUser(arg0 string, arg1 ...string) (bool, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteRolesForUser", varargs...)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockIDistributedEnforcerMockRecorder) DeleteRolesForUser(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRolesForUser", reflect.TypeOf((*MockIDistributedEnforcer)(nil).DeleteRolesForUser), varargs...)
}
func (m *MockIDistributedEnforcer) DeleteUser(arg0 string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteUser", arg0)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockIDistributedEnforcerMockRecorder) DeleteUser(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteUser", reflect.TypeOf((*MockIDistributedEnforcer)(nil).DeleteUser), arg0)
}
func (m *MockIDistributedEnforcer) EnableAutoBuildRoleLinks(arg0 bool) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "EnableAutoBuildRoleLinks", arg0)
}
func (mr *MockIDistributedEnforcerMockRecorder) EnableAutoBuildRoleLinks(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableAutoBuildRoleLinks", reflect.TypeOf((*MockIDistributedEnforcer)(nil).EnableAutoBuildRoleLinks), arg0)
}
func (m *MockIDistributedEnforcer) EnableAutoNotifyWatcher(arg0 bool) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "EnableAutoNotifyWatcher", arg0)
}
func (mr *MockIDistributedEnforcerMockRecorder) EnableAutoNotifyWatcher(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableAutoNotifyWatcher", reflect.TypeOf((*MockIDistributedEnforcer)(nil).EnableAutoNotifyWatcher), arg0)
}
func (m *MockIDistributedEnforcer) EnableAutoSave(arg0 bool) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "EnableAutoSave", arg0)
}
func (mr *MockIDistributedEnforcerMockRecorder) EnableAutoSave(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableAutoSave", reflect.TypeOf((*MockIDistributedEnforcer)(nil).EnableAutoSave), arg0)
}
func (m *MockIDistributedEnforcer) EnableEnforce(arg0 bool) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "EnableEnforce", arg0)
}
func (mr *MockIDistributedEnforcerMockRecorder) EnableEnforce(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableEnforce", reflect.TypeOf((*MockIDistributedEnforcer)(nil).EnableEnforce), arg0)
}
func (m *MockIDistributedEnforcer) EnableLog(arg0 bool) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "EnableLog", arg0)
}
func (mr *MockIDistributedEnforcerMockRecorder) EnableLog(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableLog", reflect.TypeOf((*MockIDistributedEnforcer)(nil).EnableLog), arg0)
}
func (m *MockIDistributedEnforcer) Enforce(arg0 ...interface{}) (bool, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{}
	for _, a := range arg0 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Enforce", varargs...)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockIDistributedEnforcerMockRecorder) Enforce(arg0 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Enforce", reflect.TypeOf((*MockIDistributedEnforcer)(nil).Enforce), arg0...)
}
func (m *MockIDistributedEnforcer) EnforceEx(arg0 ...interface{}) (bool, []string, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{}
	for _, a := range arg0 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "EnforceEx", varargs...)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].([]string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}
func (mr *MockIDistributedEnforcerMockRecorder) EnforceEx(arg0 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnforceEx", reflect.TypeOf((*MockIDistributedEnforcer)(nil).EnforceEx), arg0...)
}
func (m *MockIDistributedEnforcer) EnforceExWithMatcher(arg0 string, arg1 ...interface{}) (bool, []string, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "EnforceExWithMatcher", varargs...)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].([]string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}
func (mr *MockIDistributedEnforcerMockRecorder) EnforceExWithMatcher(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnforceExWithMatcher", reflect.TypeOf((*MockIDistributedEnforcer)(nil).EnforceExWithMatcher), varargs...)
}
func (m *MockIDistributedEnforcer) EnforceWithMatcher(arg0 string, arg1 ...interface{}) (bool, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "EnforceWithMatcher", varargs...)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockIDistributedEnforcerMockRecorder) EnforceWithMatcher(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnforceWithMatcher", reflect.TypeOf((*MockIDistributedEnforcer)(nil).EnforceWithMatcher), varargs...)
}
func (m *MockIDistributedEnforcer) GetAdapter() persist.Adapter {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAdapter")
	ret0, _ := ret[0].(persist.Adapter)
	return ret0
}
func (mr *MockIDistributedEnforcerMockRecorder) GetAdapter() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAdapter", reflect.TypeOf((*MockIDistributedEnforcer)(nil).GetAdapter))
}
func (m *MockIDistributedEnforcer) GetAllActions() []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAllActions")
	ret0, _ := ret[0].([]string)
	return ret0
}
func (mr *MockIDistributedEnforcerMockRecorder) GetAllActions() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllActions", reflect.TypeOf((*MockIDistributedEnforcer)(nil).GetAllActions))
}
func (m *MockIDistributedEnforcer) GetAllNamedActions(arg0 string) []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAllNamedActions", arg0)
	ret0, _ := ret[0].([]string)
	return ret0
}
func (mr *MockIDistributedEnforcerMockRecorder) GetAllNamedActions(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllNamedActions", reflect.TypeOf((*MockIDistributedEnforcer)(nil).GetAllNamedActions), arg0)
}
func (m *MockIDistributedEnforcer) GetAllNamedObjects(arg0 string) []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAllNamedObjects", arg0)
	ret0, _ := ret[0].([]string)
	return ret0
}
func (mr *MockIDistributedEnforcerMockRecorder) GetAllNamedObjects(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllNamedObjects", reflect.TypeOf((*MockIDistributedEnforcer)(nil).GetAllNamedObjects), arg0)
}
func (m *MockIDistributedEnforcer) GetAllNamedRoles(arg0 string) []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAllNamedRoles", arg0)
	ret0, _ := ret[0].([]string)
	return ret0
}
func (mr *MockIDistributedEnforcerMockRecorder) GetAllNamedRoles(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllNamedRoles", reflect.TypeOf((*MockIDistributedEnforcer)(nil).GetAllNamedRoles), arg0)
}
func (m *MockIDistributedEnforcer) GetAllNamedSubjects(arg0 string) []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAllNamedSubjects", arg0)
	ret0, _ := ret[0].([]string)
	return ret0
}
func (mr *MockIDistributedEnforcerMockRecorder) GetAllNamedSubjects(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllNamedSubjects", reflect.TypeOf((*MockIDistributedEnforcer)(nil).GetAllNamedSubjects), arg0)
}
func (m *MockIDistributedEnforcer) GetAllObjects() []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAllObjects")
	ret0, _ := ret[0].([]string)
	return ret0
}
func (mr *MockIDistributedEnforcerMockRecorder) GetAllObjects() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllObjects", reflect.TypeOf((*MockIDistributedEnforcer)(nil).GetAllObjects))
}
func (m *MockIDistributedEnforcer) GetAllRoles() []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAllRoles")
	ret0, _ := ret[0].([]string)
	return ret0
}
func (mr *MockIDistributedEnforcerMockRecorder) GetAllRoles() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllRoles", reflect.TypeOf((*MockIDistributedEnforcer)(nil).GetAllRoles))
}
func (m *MockIDistributedEnforcer) GetAllSubjects() []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAllSubjects")
	ret0, _ := ret[0].([]string)
	return ret0
}
func (mr *MockIDistributedEnforcerMockRecorder) GetAllSubjects() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllSubjects", reflect.TypeOf((*MockIDistributedEnforcer)(nil).GetAllSubjects))
}
func (m *MockIDistributedEnforcer) GetFilteredGroupingPolicy(arg0 int, arg1 ...string) [][]string {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetFilteredGroupingPolicy", varargs...)
	ret0, _ := ret[0].([][]string)
	return ret0
}
func (mr *MockIDistributedEnforcerMockRecorder) GetFilteredGroupingPolicy(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFilteredGroupingPolicy", reflect.TypeOf((*MockIDistributedEnforcer)(nil).GetFilteredGroupingPolicy), varargs...)
}
func (m *MockIDistributedEnforcer) GetFilteredNamedGroupingPolicy(arg0 string, arg1 int, arg2 ...string) [][]string {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetFilteredNamedGroupingPolicy", varargs...)
	ret0, _ := ret[0].([][]string)
	return ret0
}
func (mr *MockIDistributedEnforcerMockRecorder) GetFilteredNamedGroupingPolicy(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFilteredNamedGroupingPolicy", reflect.TypeOf((*MockIDistributedEnforcer)(nil).GetFilteredNamedGroupingPolicy), varargs...)
}
func (m *MockIDistributedEnforcer) GetFilteredNamedPolicy(arg0 string, arg1 int, arg2 ...string) [][]string {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetFilteredNamedPolicy", varargs...)
	ret0, _ := ret[0].([][]string)
	return ret0
}
func (mr *MockIDistributedEnforcerMockRecorder) GetFilteredNamedPolicy(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFilteredNamedPolicy", reflect.TypeOf((*MockIDistributedEnforcer)(nil).GetFilteredNamedPolicy), varargs...)
}
func (m *MockIDistributedEnforcer) GetFilteredPolicy(arg0 int, arg1 ...string) [][]string {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetFilteredPolicy", varargs...)
	ret0, _ := ret[0].([][]string)
	return ret0
}