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

package dbus

import (
	"context"

	"github.com/godbus/dbus/v5"
	mock "github.com/stretchr/testify/mock"
)

// NewMockBusObject creates a new instance of MockBusObject. 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 NewMockBusObject(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockBusObject {
	mock := &MockBusObject{}
	mock.Mock.Test(t)

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

	return mock
}

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

type MockBusObject_Expecter struct {
	mock *mock.Mock
}

func (_m *MockBusObject) EXPECT() *MockBusObject_Expecter {
	return &MockBusObject_Expecter{mock: &_m.Mock}
}

// AddMatchSignal provides a mock function for the type MockBusObject
func (_mock *MockBusObject) AddMatchSignal(iface string, member string, options ...dbus.MatchOption) *dbus.Call {
	// dbus.MatchOption
	_va := make([]any, len(options))
	for _i := range options {
		_va[_i] = options[_i]
	}
	var _ca []any
	_ca = append(_ca, iface, member)
	_ca = append(_ca, _va...)
	ret := _mock.Called(_ca...)

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

	var r0 *dbus.Call
	if returnFunc, ok := ret.Get(0).(func(string, string, ...dbus.MatchOption) *dbus.Call); ok {
		r0 = returnFunc(iface, member, options...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dbus.Call)
		}
	}
	return r0
}

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

// AddMatchSignal is a helper method to define mock.On call
//   - iface string
//   - member string
//   - options ...dbus.MatchOption
func (_e *MockBusObject_Expecter) AddMatchSignal(iface any, member any, options ...any) *MockBusObject_AddMatchSignal_Call {
	return &MockBusObject_AddMatchSignal_Call{Call: _e.mock.On("AddMatchSignal",
		append([]any{iface, member}, options...)...)}
}

func (_c *MockBusObject_AddMatchSignal_Call) Run(run func(iface string, member string, options ...dbus.MatchOption)) *MockBusObject_AddMatchSignal_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 []dbus.MatchOption
		variadicArgs := make([]dbus.MatchOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(dbus.MatchOption)
			}
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *MockBusObject_AddMatchSignal_Call) Return(call *dbus.Call) *MockBusObject_AddMatchSignal_Call {
	_c.Call.Return(call)
	return _c
}

func (_c *MockBusObject_AddMatchSignal_Call) RunAndReturn(run func(iface string, member string, options ...dbus.MatchOption) *dbus.Call) *MockBusObject_AddMatchSignal_Call {
	_c.Call.Return(run)
	return _c
}

// Call provides a mock function for the type MockBusObject
func (_mock *MockBusObject) Call(method string, flags dbus.Flags, args ...any) *dbus.Call {
	var _ca []any
	_ca = append(_ca, method, flags)
	_ca = append(_ca, args...)
	ret := _mock.Called(_ca...)

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

	var r0 *dbus.Call
	if returnFunc, ok := ret.Get(0).(func(string, dbus.Flags, ...any) *dbus.Call); ok {
		r0 = returnFunc(method, flags, args...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dbus.Call)
		}
	}
	return r0
}

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

// Call is a helper method to define mock.On call
//   - method string
//   - flags dbus.Flags
//   - args ...any
func (_e *MockBusObject_Expecter) Call(method any, flags any, args ...any) *MockBusObject_Call_Call {
	return &MockBusObject_Call_Call{Call: _e.mock.On("Call",
		append([]any{method, flags}, args...)...)}
}

func (_c *MockBusObject_Call_Call) Run(run func(method string, flags dbus.Flags, args ...any)) *MockBusObject_Call_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 dbus.Flags
		if args[1] != nil {
			arg1 = args[1].(dbus.Flags)
		}
		var arg2 []any
		variadicArgs := make([]any, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(any)
			}
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *MockBusObject_Call_Call) Return(call *dbus.Call) *MockBusObject_Call_Call {
	_c.Call.Return(call)
	return _c
}

func (_c *MockBusObject_Call_Call) RunAndReturn(run func(method string, flags dbus.Flags, args ...any) *dbus.Call) *MockBusObject_Call_Call {
	_c.Call.Return(run)
	return _c
}

// CallWithContext provides a mock function for the type MockBusObject
func (_mock *MockBusObject) CallWithContext(ctx context.Context, method string, flags dbus.Flags, args ...any) *dbus.Call {
	var _ca []any
	_ca = append(_ca, ctx, method, flags)
	_ca = append(_ca, args...)
	ret := _mock.Called(_ca...)

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

	var r0 *dbus.Call
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, dbus.Flags, ...any) *dbus.Call); ok {
		r0 = returnFunc(ctx, method, flags, args...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dbus.Call)
		}
	}
	return r0
}

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

// CallWithContext is a helper method to define mock.On call
//   - ctx context.Context
//   - method string
//   - flags dbus.Flags
//   - args ...any
func (_e *MockBusObject_Expecter) CallWithContext(ctx any, method any, flags any, args ...any) *MockBusObject_CallWithContext_Call {
	return &MockBusObject_CallWithContext_Call{Call: _e.mock.On("CallWithContext",
		append([]any{ctx, method, flags}, args...)...)}
}

func (_c *MockBusObject_CallWithContext_Call) Run(run func(ctx context.Context, method string, flags dbus.Flags, args ...any)) *MockBusObject_CallWithContext_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 dbus.Flags
		if args[2] != nil {
			arg2 = args[2].(dbus.Flags)
		}
		var arg3 []any
		variadicArgs := make([]any, len(args)-3)
		for i, a := range args[3:] {
			if a != nil {
				variadicArgs[i] = a.(any)
			}
		}
		arg3 = variadicArgs
		run(
			arg0,
			arg1,
			arg2,
			arg3...,
		)
	})
	return _c
}

func (_c *MockBusObject_CallWithContext_Call) Return(call *dbus.Call) *MockBusObject_CallWithContext_Call {
	_c.Call.Return(call)
	return _c
}

func (_c *MockBusObject_CallWithContext_Call) RunAndReturn(run func(ctx context.Context, method string, flags dbus.Flags, args ...any) *dbus.Call) *MockBusObject_CallWithContext_Call {
	_c.Call.Return(run)
	return _c
}

// Destination provides a mock function for the type MockBusObject
func (_mock *MockBusObject) Destination() string {
	ret := _mock.Called()

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

	var r0 string
	if returnFunc, ok := ret.Get(0).(func() string); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(string)
	}
	return r0
}

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

// Destination is a helper method to define mock.On call
func (_e *MockBusObject_Expecter) Destination() *MockBusObject_Destination_Call {
	return &MockBusObject_Destination_Call{Call: _e.mock.On("Destination")}
}

func (_c *MockBusObject_Destination_Call) Run(run func()) *MockBusObject_Destination_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockBusObject_Destination_Call) Return(s string) *MockBusObject_Destination_Call {
	_c.Call.Return(s)
	return _c
}

func (_c *MockBusObject_Destination_Call) RunAndReturn(run func() string) *MockBusObject_Destination_Call {
	_c.Call.Return(run)
	return _c
}

// GetProperty provides a mock function for the type MockBusObject
func (_mock *MockBusObject) GetProperty(p string) (dbus.Variant, error) {
	ret := _mock.Called(p)

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

	var r0 dbus.Variant
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(string) (dbus.Variant, error)); ok {
		return returnFunc(p)
	}
	if returnFunc, ok := ret.Get(0).(func(string) dbus.Variant); ok {
		r0 = returnFunc(p)
	} else {
		r0 = ret.Get(0).(dbus.Variant)
	}
	if returnFunc, ok := ret.Get(1).(func(string) error); ok {
		r1 = returnFunc(p)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetProperty is a helper method to define mock.On call
//   - p string
func (_e *MockBusObject_Expecter) GetProperty(p any) *MockBusObject_GetProperty_Call {
	return &MockBusObject_GetProperty_Call{Call: _e.mock.On("GetProperty", p)}
}

func (_c *MockBusObject_GetProperty_Call) Run(run func(p string)) *MockBusObject_GetProperty_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockBusObject_GetProperty_Call) Return(variant dbus.Variant, err error) *MockBusObject_GetProperty_Call {
	_c.Call.Return(variant, err)
	return _c
}

func (_c *MockBusObject_GetProperty_Call) RunAndReturn(run func(p string) (dbus.Variant, error)) *MockBusObject_GetProperty_Call {
	_c.Call.Return(run)
	return _c
}

// Go provides a mock function for the type MockBusObject
func (_mock *MockBusObject) Go(method string, flags dbus.Flags, ch chan *dbus.Call, args ...any) *dbus.Call {
	var _ca []any
	_ca = append(_ca, method, flags, ch)
	_ca = append(_ca, args...)
	ret := _mock.Called(_ca...)

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

	var r0 *dbus.Call
	if returnFunc, ok := ret.Get(0).(func(string, dbus.Flags, chan *dbus.Call, ...any) *dbus.Call); ok {
		r0 = returnFunc(method, flags, ch, args...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dbus.Call)
		}
	}
	return r0
}

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

// Go is a helper method to define mock.On call
//   - method string
//   - flags dbus.Flags
//   - ch chan *dbus.Call
//   - args ...any
func (_e *MockBusObject_Expecter) Go(method any, flags any, ch any, args ...any) *MockBusObject_Go_Call {
	return &MockBusObject_Go_Call{Call: _e.mock.On("Go",
		append([]any{method, flags, ch}, args...)...)}
}

func (_c *MockBusObject_Go_Call) Run(run func(method string, flags dbus.Flags, ch chan *dbus.Call, args ...any)) *MockBusObject_Go_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 dbus.Flags
		if args[1] != nil {
			arg1 = args[1].(dbus.Flags)
		}
		var arg2 chan *dbus.Call
		if args[2] != nil {
			arg2 = args[2].(chan *dbus.Call)
		}
		var arg3 []any
		variadicArgs := make([]any, len(args)-3)
		for i, a := range args[3:] {
			if a != nil {
				variadicArgs[i] = a.(any)
			}
		}
		arg3 = variadicArgs
		run(
			arg0,
			arg1,
			arg2,
			arg3...,
		)
	})
	return _c
}

func (_c *MockBusObject_Go_Call) Return(call *dbus.Call) *MockBusObject_Go_Call {
	_c.Call.Return(call)
	return _c
}

func (_c *MockBusObject_Go_Call) RunAndReturn(run func(method string, flags dbus.Flags, ch chan *dbus.Call, args ...any) *dbus.Call) *MockBusObject_Go_Call {
	_c.Call.Return(run)
	return _c
}

// GoWithContext provides a mock function for the type MockBusObject
func (_mock *MockBusObject) GoWithContext(ctx context.Context, method string, flags dbus.Flags, ch chan *dbus.Call, args ...any) *dbus.Call {
	var _ca []any
	_ca = append(_ca, ctx, method, flags, ch)
	_ca = append(_ca, args...)
	ret := _mock.Called(_ca...)

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

	var r0 *dbus.Call
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, dbus.Flags, chan *dbus.Call, ...any) *dbus.Call); ok {
		r0 = returnFunc(ctx, method, flags, ch, args...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dbus.Call)
		}
	}
	return r0
}

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

// GoWithContext is a helper method to define mock.On call
//   - ctx context.Context
//   - method string
//   - flags dbus.Flags
//   - ch chan *dbus.Call
//   - args ...any
func (_e *MockBusObject_Expecter) GoWithContext(ctx any, method any, flags any, ch any, args ...any) *MockBusObject_GoWithContext_Call {
	return &MockBusObject_GoWithContext_Call{Call: _e.mock.On("GoWithContext",
		append([]any{ctx, method, flags, ch}, args...)...)}
}

func (_c *MockBusObject_GoWithContext_Call) Run(run func(ctx context.Context, method string, flags dbus.Flags, ch chan *dbus.Call, args ...any)) *MockBusObject_GoWithContext_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 dbus.Flags
		if args[2] != nil {
			arg2 = args[2].(dbus.Flags)
		}
		var arg3 chan *dbus.Call
		if args[3] != nil {
			arg3 = args[3].(chan *dbus.Call)
		}
		var arg4 []any
		variadicArgs := make([]any, len(args)-4)
		for i, a := range args[4:] {
			if a != nil {
				variadicArgs[i] = a.(any)
			}
		}
		arg4 = variadicArgs
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4...,
		)
	})
	return _c
}

func (_c *MockBusObject_GoWithContext_Call) Return(call *dbus.Call) *MockBusObject_GoWithContext_Call {
	_c.Call.Return(call)
	return _c
}

func (_c *MockBusObject_GoWithContext_Call) RunAndReturn(run func(ctx context.Context, method string, flags dbus.Flags, ch chan *dbus.Call, args ...any) *dbus.Call) *MockBusObject_GoWithContext_Call {
	_c.Call.Return(run)
	return _c
}

// Path provides a mock function for the type MockBusObject
func (_mock *MockBusObject) Path() dbus.ObjectPath {
	ret := _mock.Called()

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

	var r0 dbus.ObjectPath
	if returnFunc, ok := ret.Get(0).(func() dbus.ObjectPath); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(dbus.ObjectPath)
	}
	return r0
}

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

// Path is a helper method to define mock.On call
func (_e *MockBusObject_Expecter) Path() *MockBusObject_Path_Call {
	return &MockBusObject_Path_Call{Call: _e.mock.On("Path")}
}

func (_c *MockBusObject_Path_Call) Run(run func()) *MockBusObject_Path_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockBusObject_Path_Call) Return(objectPath dbus.ObjectPath) *MockBusObject_Path_Call {
	_c.Call.Return(objectPath)
	return _c
}

func (_c *MockBusObject_Path_Call) RunAndReturn(run func() dbus.ObjectPath) *MockBusObject_Path_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveMatchSignal provides a mock function for the type MockBusObject
func (_mock *MockBusObject) RemoveMatchSignal(iface string, member string, options ...dbus.MatchOption) *dbus.Call {
	// dbus.MatchOption
	_va := make([]any, len(options))
	for _i := range options {
		_va[_i] = options[_i]
	}
	var _ca []any
	_ca = append(_ca, iface, member)
	_ca = append(_ca, _va...)
	ret := _mock.Called(_ca...)

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

	var r0 *dbus.Call
	if returnFunc, ok := ret.Get(0).(func(string, string, ...dbus.MatchOption) *dbus.Call); ok {
		r0 = returnFunc(iface, member, options...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dbus.Call)
		}
	}
	return r0
}

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

// RemoveMatchSignal is a helper method to define mock.On call
//   - iface string
//   - member string
//   - options ...dbus.MatchOption
func (_e *MockBusObject_Expecter) RemoveMatchSignal(iface any, member any, options ...any) *MockBusObject_RemoveMatchSignal_Call {
	return &MockBusObject_RemoveMatchSignal_Call{Call: _e.mock.On("RemoveMatchSignal",
		append([]any{iface, member}, options...)...)}
}

func (_c *MockBusObject_RemoveMatchSignal_Call) Run(run func(iface string, member string, options ...dbus.MatchOption)) *MockBusObject_RemoveMatchSignal_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 []dbus.MatchOption
		variadicArgs := make([]dbus.MatchOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(dbus.MatchOption)
			}
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *MockBusObject_RemoveMatchSignal_Call) Return(call *dbus.Call) *MockBusObject_RemoveMatchSignal_Call {
	_c.Call.Return(call)
	return _c
}

func (_c *MockBusObject_RemoveMatchSignal_Call) RunAndReturn(run func(iface string, member string, options ...dbus.MatchOption) *dbus.Call) *MockBusObject_RemoveMatchSignal_Call {
	_c.Call.Return(run)
	return _c
}

// SetProperty provides a mock function for the type MockBusObject
func (_mock *MockBusObject) SetProperty(p string, v any) error {
	ret := _mock.Called(p, v)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(string, any) error); ok {
		r0 = returnFunc(p, v)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// SetProperty is a helper method to define mock.On call
//   - p string
//   - v any
func (_e *MockBusObject_Expecter) SetProperty(p any, v any) *MockBusObject_SetProperty_Call {
	return &MockBusObject_SetProperty_Call{Call: _e.mock.On("SetProperty", p, v)}
}

func (_c *MockBusObject_SetProperty_Call) Run(run func(p string, v any)) *MockBusObject_SetProperty_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 any
		if args[1] != nil {
			arg1 = args[1].(any)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockBusObject_SetProperty_Call) RunAndReturn(run func(p string, v any) error) *MockBusObject_SetProperty_Call {
	_c.Call.Return(run)
	return _c
}

// StoreProperty provides a mock function for the type MockBusObject
func (_mock *MockBusObject) StoreProperty(p string, value any) error {
	ret := _mock.Called(p, value)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(string, any) error); ok {
		r0 = returnFunc(p, value)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// StoreProperty is a helper method to define mock.On call
//   - p string
//   - value any
func (_e *MockBusObject_Expecter) StoreProperty(p any, value any) *MockBusObject_StoreProperty_Call {
	return &MockBusObject_StoreProperty_Call{Call: _e.mock.On("StoreProperty", p, value)}
}

func (_c *MockBusObject_StoreProperty_Call) Run(run func(p string, value any)) *MockBusObject_StoreProperty_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 any
		if args[1] != nil {
			arg1 = args[1].(any)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockBusObject_StoreProperty_Call) RunAndReturn(run func(p string, value any) error) *MockBusObject_StoreProperty_Call {
	_c.Call.Return(run)
	return _c
}
