// Code generated by mockery; DO NOT EDIT.
// github.com/vektra/mockery
// template: testify

package mocks

import (
	"context"

	"github.com/agntcy/identity-service/internal/core/policy/types"
	"github.com/agntcy/identity-service/internal/pkg/pagination"
	mock "github.com/stretchr/testify/mock"
)

// NewPolicyService creates a new instance of PolicyService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewPolicyService(t interface {
	mock.TestingT
	Cleanup(func())
}) *PolicyService {
	mock := &PolicyService{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}

// PolicyService is an autogenerated mock type for the PolicyService type
type PolicyService struct {
	mock.Mock
}

type PolicyService_Expecter struct {
	mock *mock.Mock
}

func (_m *PolicyService) EXPECT() *PolicyService_Expecter {
	return &PolicyService_Expecter{mock: &_m.Mock}
}

// CountAllPolicies provides a mock function for the type PolicyService
func (_mock *PolicyService) CountAllPolicies(ctx context.Context) (int64, error) {
	ret := _mock.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for CountAllPolicies")
	}

	var r0 int64
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context) (int64, error)); ok {
		return returnFunc(ctx)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context) int64); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(int64)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = returnFunc(ctx)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// PolicyService_CountAllPolicies_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CountAllPolicies'
type PolicyService_CountAllPolicies_Call struct {
	*mock.Call
}

// CountAllPolicies is a helper method to define mock.On call
//   - ctx context.Context
func (_e *PolicyService_Expecter) CountAllPolicies(ctx interface{}) *PolicyService_CountAllPolicies_Call {
	return &PolicyService_CountAllPolicies_Call{Call: _e.mock.On("CountAllPolicies", ctx)}
}

func (_c *PolicyService_CountAllPolicies_Call) Run(run func(ctx context.Context)) *PolicyService_CountAllPolicies_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *PolicyService_CountAllPolicies_Call) Return(n int64, err error) *PolicyService_CountAllPolicies_Call {
	_c.Call.Return(n, err)
	return _c
}

func (_c *PolicyService_CountAllPolicies_Call) RunAndReturn(run func(ctx context.Context) (int64, error)) *PolicyService_CountAllPolicies_Call {
	_c.Call.Return(run)
	return _c
}

// CreatePolicy provides a mock function for the type PolicyService
func (_mock *PolicyService) CreatePolicy(ctx context.Context, name string, description string, assignedTo string) (*types.Policy, error) {
	ret := _mock.Called(ctx, name, description, assignedTo)

	if len(ret) == 0 {
		panic("no return value specified for CreatePolicy")
	}

	var r0 *types.Policy
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (*types.Policy, error)); ok {
		return returnFunc(ctx, name, description, assignedTo)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) *types.Policy); ok {
		r0 = returnFunc(ctx, name, description, assignedTo)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.Policy)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
		r1 = returnFunc(ctx, name, description, assignedTo)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// PolicyService_CreatePolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreatePolicy'
type PolicyService_CreatePolicy_Call struct {
	*mock.Call
}

// CreatePolicy is a helper method to define mock.On call
//   - ctx context.Context
//   - name string
//   - description string
//   - assignedTo string
func (_e *PolicyService_Expecter) CreatePolicy(ctx interface{}, name interface{}, description interface{}, assignedTo interface{}) *PolicyService_CreatePolicy_Call {
	return &PolicyService_CreatePolicy_Call{Call: _e.mock.On("CreatePolicy", ctx, name, description, assignedTo)}
}

func (_c *PolicyService_CreatePolicy_Call) Run(run func(ctx context.Context, name string, description string, assignedTo string)) *PolicyService_CreatePolicy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *PolicyService_CreatePolicy_Call) Return(policy *types.Policy, err error) *PolicyService_CreatePolicy_Call {
	_c.Call.Return(policy, err)
	return _c
}

func (_c *PolicyService_CreatePolicy_Call) RunAndReturn(run func(ctx context.Context, name string, description string, assignedTo string) (*types.Policy, error)) *PolicyService_CreatePolicy_Call {
	_c.Call.Return(run)
	return _c
}

// CreateRule provides a mock function for the type PolicyService
func (_mock *PolicyService) CreateRule(ctx context.Context, policyID string, name string, description string, taskIDs []string, needsApproval bool, action types.RuleAction) (*types.Rule, error) {
	ret := _mock.Called(ctx, policyID, name, description, taskIDs, needsApproval, action)

	if len(ret) == 0 {
		panic("no return value specified for CreateRule")
	}

	var r0 *types.Rule
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, []string, bool, types.RuleAction) (*types.Rule, error)); ok {
		return returnFunc(ctx, policyID, name, description, taskIDs, needsApproval, action)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, []string, bool, types.RuleAction) *types.Rule); ok {
		r0 = returnFunc(ctx, policyID, name, description, taskIDs, needsApproval, action)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.Rule)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, []string, bool, types.RuleAction) error); ok {
		r1 = returnFunc(ctx, policyID, name, description, taskIDs, needsApproval, action)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// PolicyService_CreateRule_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateRule'
type PolicyService_CreateRule_Call struct {
	*mock.Call
}

// CreateRule is a helper method to define mock.On call
//   - ctx context.Context
//   - policyID string
//   - name string
//   - description string
//   - taskIDs []string
//   - needsApproval bool
//   - action types.RuleAction
func (_e *PolicyService_Expecter) CreateRule(ctx interface{}, policyID interface{}, name interface{}, description interface{}, taskIDs interface{}, needsApproval interface{}, action interface{}) *PolicyService_CreateRule_Call {
	return &PolicyService_CreateRule_Call{Call: _e.mock.On("CreateRule", ctx, policyID, name, description, taskIDs, needsApproval, action)}
}

func (_c *PolicyService_CreateRule_Call) Run(run func(ctx context.Context, policyID string, name string, description string, taskIDs []string, needsApproval bool, action types.RuleAction)) *PolicyService_CreateRule_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 []string
		if args[4] != nil {
			arg4 = args[4].([]string)
		}
		var arg5 bool
		if args[5] != nil {
			arg5 = args[5].(bool)
		}
		var arg6 types.RuleAction
		if args[6] != nil {
			arg6 = args[6].(types.RuleAction)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
			arg5,
			arg6,
		)
	})
	return _c
}

func (_c *PolicyService_CreateRule_Call) Return(rule *types.Rule, err error) *PolicyService_CreateRule_Call {
	_c.Call.Return(rule, err)
	return _c
}

func (_c *PolicyService_CreateRule_Call) RunAndReturn(run func(ctx context.Context, policyID string, name string, description string, taskIDs []string, needsApproval bool, action types.RuleAction) (*types.Rule, error)) *PolicyService_CreateRule_Call {
	_c.Call.Return(run)
	return _c
}

// DeletePolicy provides a mock function for the type PolicyService
func (_mock *PolicyService) DeletePolicy(ctx context.Context, id string) error {
	ret := _mock.Called(ctx, id)

	if len(ret) == 0 {
		panic("no return value specified for DeletePolicy")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
		r0 = returnFunc(ctx, id)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// PolicyService_DeletePolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeletePolicy'
type PolicyService_DeletePolicy_Call struct {
	*mock.Call
}

// DeletePolicy is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *PolicyService_Expecter) DeletePolicy(ctx interface{}, id interface{}) *PolicyService_DeletePolicy_Call {
	return &PolicyService_DeletePolicy_Call{Call: _e.mock.On("DeletePolicy", ctx, id)}
}

func (_c *PolicyService_DeletePolicy_Call) Run(run func(ctx context.Context, id string)) *PolicyService_DeletePolicy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *PolicyService_DeletePolicy_Call) Return(err error) *PolicyService_DeletePolicy_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *PolicyService_DeletePolicy_Call) RunAndReturn(run func(ctx context.Context, id string) error) *PolicyService_DeletePolicy_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteRule provides a mock function for the type PolicyService
func (_mock *PolicyService) DeleteRule(ctx context.Context, ruleID string, policyID string) error {
	ret := _mock.Called(ctx, ruleID, policyID)

	if len(ret) == 0 {
		panic("no return value specified for DeleteRule")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
		r0 = returnFunc(ctx, ruleID, policyID)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// PolicyService_DeleteRule_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteRule'
type PolicyService_DeleteRule_Call struct {
	*mock.Call
}

// DeleteRule is a helper method to define mock.On call
//   - ctx context.Context
//   - ruleID string
//   - policyID string
func (_e *PolicyService_Expecter) DeleteRule(ctx interface{}, ruleID interface{}, policyID interface{}) *PolicyService_DeleteRule_Call {
	return &PolicyService_DeleteRule_Call{Call: _e.mock.On("DeleteRule", ctx, ruleID, policyID)}
}

func (_c *PolicyService_DeleteRule_Call) Run(run func(ctx context.Context, ruleID string, policyID string)) *PolicyService_DeleteRule_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *PolicyService_DeleteRule_Call) Return(err error) *PolicyService_DeleteRule_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *PolicyService_DeleteRule_Call) RunAndReturn(run func(ctx context.Context, ruleID string, policyID string) error) *PolicyService_DeleteRule_Call {
	_c.Call.Return(run)
	return _c
}

// GetPolicy provides a mock function for the type PolicyService
func (_mock *PolicyService) GetPolicy(ctx context.Context, id string) (*types.Policy, error) {
	ret := _mock.Called(ctx, id)

	if len(ret) == 0 {
		panic("no return value specified for GetPolicy")
	}

	var r0 *types.Policy
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*types.Policy, error)); ok {
		return returnFunc(ctx, id)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) *types.Policy); ok {
		r0 = returnFunc(ctx, id)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.Policy)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, id)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// PolicyService_GetPolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPolicy'
type PolicyService_GetPolicy_Call struct {
	*mock.Call
}

// GetPolicy is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *PolicyService_Expecter) GetPolicy(ctx interface{}, id interface{}) *PolicyService_GetPolicy_Call {
	return &PolicyService_GetPolicy_Call{Call: _e.mock.On("GetPolicy", ctx, id)}
}

func (_c *PolicyService_GetPolicy_Call) Run(run func(ctx context.Context, id string)) *PolicyService_GetPolicy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *PolicyService_GetPolicy_Call) Return(policy *types.Policy, err error) *PolicyService_GetPolicy_Call {
	_c.Call.Return(policy, err)
	return _c
}

func (_c *PolicyService_GetPolicy_Call) RunAndReturn(run func(ctx context.Context, id string) (*types.Policy, error)) *PolicyService_GetPolicy_Call {
	_c.Call.Return(run)
	return _c
}

// GetRule provides a mock function for the type PolicyService
func (_mock *PolicyService) GetRule(ctx context.Context, ruleID string, policyID string) (*types.Rule, error) {
	ret := _mock.Called(ctx, ruleID, policyID)

	if len(ret) == 0 {
		panic("no return value specified for GetRule")
	}

	var r0 *types.Rule
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*types.Rule, error)); ok {
		return returnFunc(ctx, ruleID, policyID)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *types.Rule); ok {
		r0 = returnFunc(ctx, ruleID, policyID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.Rule)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, ruleID, policyID)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// PolicyService_GetRule_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRule'
type PolicyService_GetRule_Call struct {
	*mock.Call
}

// GetRule is a helper method to define mock.On call
//   - ctx context.Context
//   - ruleID string
//   - policyID string
func (_e *PolicyService_Expecter) GetRule(ctx interface{}, ruleID interface{}, policyID interface{}) *PolicyService_GetRule_Call {
	return &PolicyService_GetRule_Call{Call: _e.mock.On("GetRule", ctx, ruleID, policyID)}
}

func (_c *PolicyService_GetRule_Call) Run(run func(ctx context.Context, ruleID string, policyID string)) *PolicyService_GetRule_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *PolicyService_GetRule_Call) Return(rule *types.Rule, err error) *PolicyService_GetRule_Call {
	_c.Call.Return(rule, err)
	return _c
}

func (_c *PolicyService_GetRule_Call) RunAndReturn(run func(ctx context.Context, ruleID string, policyID string) (*types.Rule, error)) *PolicyService_GetRule_Call {
	_c.Call.Return(run)
	return _c
}

// ListPolicies provides a mock function for the type PolicyService
func (_mock *PolicyService) ListPolicies(ctx context.Context, paginationFilter pagination.PaginationFilter, query *string, appIDs []string, rulesForAppIDs []string) (*pagination.Pageable[types.Policy], error) {
	ret := _mock.Called(ctx, paginationFilter, query, appIDs, rulesForAppIDs)

	if len(ret) == 0 {
		panic("no return value specified for ListPolicies")
	}

	var r0 *pagination.Pageable[types.Policy]
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, pagination.PaginationFilter, *string, []string, []string) (*pagination.Pageable[types.Policy], error)); ok {
		return returnFunc(ctx, paginationFilter, query, appIDs, rulesForAppIDs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, pagination.PaginationFilter, *string, []string, []string) *pagination.Pageable[types.Policy]); ok {
		r0 = returnFunc(ctx, paginationFilter, query, appIDs, rulesForAppIDs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*pagination.Pageable[types.Policy])
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, pagination.PaginationFilter, *string, []string, []string) error); ok {
		r1 = returnFunc(ctx, paginationFilter, query, appIDs, rulesForAppIDs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// PolicyService_ListPolicies_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListPolicies'
type PolicyService_ListPolicies_Call struct {
	*mock.Call
}

// ListPolicies is a helper method to define mock.On call
//   - ctx context.Context
//   - paginationFilter pagination.PaginationFilter
//   - query *string
//   - appIDs []string
//   - rulesForAppIDs []string
func (_e *PolicyService_Expecter) ListPolicies(ctx interface{}, paginationFilter interface{}, query interface{}, appIDs interface{}, rulesForAppIDs interface{}) *PolicyService_ListPolicies_Call {
	return &PolicyService_ListPolicies_Call{Call: _e.mock.On("ListPolicies", ctx, paginationFilter, query, appIDs, rulesForAppIDs)}
}

func (_c *PolicyService_ListPolicies_Call) Run(run func(ctx context.Context, paginationFilter pagination.PaginationFilter, query *string, appIDs []string, rulesForAppIDs []string)) *PolicyService_ListPolicies_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 pagination.PaginationFilter
		if args[1] != nil {
			arg1 = args[1].(pagination.PaginationFilter)
		}
		var arg2 *string
		if args[2] != nil {
			arg2 = args[2].(*string)
		}
		var arg3 []string
		if args[3] != nil {
			arg3 = args[3].([]string)
		}
		var arg4 []string
		if args[4] != nil {
			arg4 = args[4].([]string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *PolicyService_ListPolicies_Call) Return(pageable *pagination.Pageable[types.Policy], err error) *PolicyService_ListPolicies_Call {
	_c.Call.Return(pageable, err)
	return _c
}

func (_c *PolicyService_ListPolicies_Call) RunAndReturn(run func(ctx context.Context, paginationFilter pagination.PaginationFilter, query *string, appIDs []string, rulesForAppIDs []string) (*pagination.Pageable[types.Policy], error)) *PolicyService_ListPolicies_Call {
	_c.Call.Return(run)
	return _c
}

// ListRules provides a mock function for the type PolicyService
func (_mock *PolicyService) ListRules(ctx context.Context, policyID string, paginationFilter pagination.PaginationFilter, query *string) (*pagination.Pageable[types.Rule], error) {
	ret := _mock.Called(ctx, policyID, paginationFilter, query)

	if len(ret) == 0 {
		panic("no return value specified for ListRules")
	}

	var r0 *pagination.Pageable[types.Rule]
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, pagination.PaginationFilter, *string) (*pagination.Pageable[types.Rule], error)); ok {
		return returnFunc(ctx, policyID, paginationFilter, query)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, pagination.PaginationFilter, *string) *pagination.Pageable[types.Rule]); ok {
		r0 = returnFunc(ctx, policyID, paginationFilter, query)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*pagination.Pageable[types.Rule])
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, pagination.PaginationFilter, *string) error); ok {
		r1 = returnFunc(ctx, policyID, paginationFilter, query)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// PolicyService_ListRules_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListRules'
type PolicyService_ListRules_Call struct {
	*mock.Call
}

// ListRules is a helper method to define mock.On call
//   - ctx context.Context
//   - policyID string
//   - paginationFilter pagination.PaginationFilter
//   - query *string
func (_e *PolicyService_Expecter) ListRules(ctx interface{}, policyID interface{}, paginationFilter interface{}, query interface{}) *PolicyService_ListRules_Call {
	return &PolicyService_ListRules_Call{Call: _e.mock.On("ListRules", ctx, policyID, paginationFilter, query)}
}

func (_c *PolicyService_ListRules_Call) Run(run func(ctx context.Context, policyID string, paginationFilter pagination.PaginationFilter, query *string)) *PolicyService_ListRules_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 pagination.PaginationFilter
		if args[2] != nil {
			arg2 = args[2].(pagination.PaginationFilter)
		}
		var arg3 *string
		if args[3] != nil {
			arg3 = args[3].(*string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *PolicyService_ListRules_Call) Return(pageable *pagination.Pageable[types.Rule], err error) *PolicyService_ListRules_Call {
	_c.Call.Return(pageable, err)
	return _c
}

func (_c *PolicyService_ListRules_Call) RunAndReturn(run func(ctx context.Context, policyID string, paginationFilter pagination.PaginationFilter, query *string) (*pagination.Pageable[types.Rule], error)) *PolicyService_ListRules_Call {
	_c.Call.Return(run)
	return _c
}

// UpdatePolicy provides a mock function for the type PolicyService
func (_mock *PolicyService) UpdatePolicy(ctx context.Context, id string, name string, description string, assignedTo string) (*types.Policy, error) {
	ret := _mock.Called(ctx, id, name, description, assignedTo)

	if len(ret) == 0 {
		panic("no return value specified for UpdatePolicy")
	}

	var r0 *types.Policy
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) (*types.Policy, error)); ok {
		return returnFunc(ctx, id, name, description, assignedTo)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) *types.Policy); ok {
		r0 = returnFunc(ctx, id, name, description, assignedTo)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.Policy)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, string) error); ok {
		r1 = returnFunc(ctx, id, name, description, assignedTo)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// PolicyService_UpdatePolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdatePolicy'
type PolicyService_UpdatePolicy_Call struct {
	*mock.Call
}

// UpdatePolicy is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - name string
//   - description string
//   - assignedTo string
func (_e *PolicyService_Expecter) UpdatePolicy(ctx interface{}, id interface{}, name interface{}, description interface{}, assignedTo interface{}) *PolicyService_UpdatePolicy_Call {
	return &PolicyService_UpdatePolicy_Call{Call: _e.mock.On("UpdatePolicy", ctx, id, name, description, assignedTo)}
}

func (_c *PolicyService_UpdatePolicy_Call) Run(run func(ctx context.Context, id string, name string, description string, assignedTo string)) *PolicyService_UpdatePolicy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 string
		if args[4] != nil {
			arg4 = args[4].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *PolicyService_UpdatePolicy_Call) Return(policy *types.Policy, err error) *PolicyService_UpdatePolicy_Call {
	_c.Call.Return(policy, err)
	return _c
}

func (_c *PolicyService_UpdatePolicy_Call) RunAndReturn(run func(ctx context.Context, id string, name string, description string, assignedTo string) (*types.Policy, error)) *PolicyService_UpdatePolicy_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateRule provides a mock function for the type PolicyService
func (_mock *PolicyService) UpdateRule(ctx context.Context, policyID string, ruleID string, name string, description string, taskIDs []string, needsApproval bool, action types.RuleAction) (*types.Rule, error) {
	ret := _mock.Called(ctx, policyID, ruleID, name, description, taskIDs, needsApproval, action)

	if len(ret) == 0 {
		panic("no return value specified for UpdateRule")
	}

	var r0 *types.Rule
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string, []string, bool, types.RuleAction) (*types.Rule, error)); ok {
		return returnFunc(ctx, policyID, ruleID, name, description, taskIDs, needsApproval, action)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string, []string, bool, types.RuleAction) *types.Rule); ok {
		r0 = returnFunc(ctx, policyID, ruleID, name, description, taskIDs, needsApproval, action)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.Rule)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, string, []string, bool, types.RuleAction) error); ok {
		r1 = returnFunc(ctx, policyID, ruleID, name, description, taskIDs, needsApproval, action)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// PolicyService_UpdateRule_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateRule'
type PolicyService_UpdateRule_Call struct {
	*mock.Call
}

// UpdateRule is a helper method to define mock.On call
//   - ctx context.Context
//   - policyID string
//   - ruleID string
//   - name string
//   - description string
//   - taskIDs []string
//   - needsApproval bool
//   - action types.RuleAction
func (_e *PolicyService_Expecter) UpdateRule(ctx interface{}, policyID interface{}, ruleID interface{}, name interface{}, description interface{}, taskIDs interface{}, needsApproval interface{}, action interface{}) *PolicyService_UpdateRule_Call {
	return &PolicyService_UpdateRule_Call{Call: _e.mock.On("UpdateRule", ctx, policyID, ruleID, name, description, taskIDs, needsApproval, action)}
}

func (_c *PolicyService_UpdateRule_Call) Run(run func(ctx context.Context, policyID string, ruleID string, name string, description string, taskIDs []string, needsApproval bool, action types.RuleAction)) *PolicyService_UpdateRule_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 string
		if args[4] != nil {
			arg4 = args[4].(string)
		}
		var arg5 []string
		if args[5] != nil {
			arg5 = args[5].([]string)
		}
		var arg6 bool
		if args[6] != nil {
			arg6 = args[6].(bool)
		}
		var arg7 types.RuleAction
		if args[7] != nil {
			arg7 = args[7].(types.RuleAction)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
			arg5,
			arg6,
			arg7,
		)
	})
	return _c
}

func (_c *PolicyService_UpdateRule_Call) Return(rule *types.Rule, err error) *PolicyService_UpdateRule_Call {
	_c.Call.Return(rule, err)
	return _c
}

func (_c *PolicyService_UpdateRule_Call) RunAndReturn(run func(ctx context.Context, policyID string, ruleID string, name string, description string, taskIDs []string, needsApproval bool, action types.RuleAction) (*types.Rule, error)) *PolicyService_UpdateRule_Call {
	_c.Call.Return(run)
	return _c
}
