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

package service

import (
	"context"

	"github.com/akeylesslabs/akeyless-go/v4"
	mock "github.com/stretchr/testify/mock"
)

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

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

	return mock
}

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

type mockAkeylessAPIClient_Expecter struct {
	mock *mock.Mock
}

func (_m *mockAkeylessAPIClient) EXPECT() *mockAkeylessAPIClient_Expecter {
	return &mockAkeylessAPIClient_Expecter{mock: &_m.Mock}
}

// Auth provides a mock function for the type mockAkeylessAPIClient
func (_mock *mockAkeylessAPIClient) Auth(ctx context.Context, params akeyless.Auth) (akeyless.AuthOutput, error) {
	ret := _mock.Called(ctx, params)

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

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

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

// Auth is a helper method to define mock.On call
//   - ctx context.Context
//   - params akeyless.Auth
func (_e *mockAkeylessAPIClient_Expecter) Auth(ctx interface{}, params interface{}) *mockAkeylessAPIClient_Auth_Call {
	return &mockAkeylessAPIClient_Auth_Call{Call: _e.mock.On("Auth", ctx, params)}
}

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

func (_c *mockAkeylessAPIClient_Auth_Call) Return(authOutput akeyless.AuthOutput, err error) *mockAkeylessAPIClient_Auth_Call {
	_c.Call.Return(authOutput, err)
	return _c
}

func (_c *mockAkeylessAPIClient_Auth_Call) RunAndReturn(run func(ctx context.Context, params akeyless.Auth) (akeyless.AuthOutput, error)) *mockAkeylessAPIClient_Auth_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeItem provides a mock function for the type mockAkeylessAPIClient
func (_mock *mockAkeylessAPIClient) DescribeItem(ctx context.Context, params akeyless.DescribeItem) (akeyless.Item, error) {
	ret := _mock.Called(ctx, params)

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

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

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

// DescribeItem is a helper method to define mock.On call
//   - ctx context.Context
//   - params akeyless.DescribeItem
func (_e *mockAkeylessAPIClient_Expecter) DescribeItem(ctx interface{}, params interface{}) *mockAkeylessAPIClient_DescribeItem_Call {
	return &mockAkeylessAPIClient_DescribeItem_Call{Call: _e.mock.On("DescribeItem", ctx, params)}
}

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

func (_c *mockAkeylessAPIClient_DescribeItem_Call) Return(item akeyless.Item, err error) *mockAkeylessAPIClient_DescribeItem_Call {
	_c.Call.Return(item, err)
	return _c
}

func (_c *mockAkeylessAPIClient_DescribeItem_Call) RunAndReturn(run func(ctx context.Context, params akeyless.DescribeItem) (akeyless.Item, error)) *mockAkeylessAPIClient_DescribeItem_Call {
	_c.Call.Return(run)
	return _c
}

// GetDynamicSecretValue provides a mock function for the type mockAkeylessAPIClient
func (_mock *mockAkeylessAPIClient) GetDynamicSecretValue(ctx context.Context, params akeyless.GetDynamicSecretValue) (map[string]any, error) {
	ret := _mock.Called(ctx, params)

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

	var r0 map[string]any
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, akeyless.GetDynamicSecretValue) (map[string]any, error)); ok {
		return returnFunc(ctx, params)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, akeyless.GetDynamicSecretValue) map[string]any); ok {
		r0 = returnFunc(ctx, params)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[string]any)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, akeyless.GetDynamicSecretValue) error); ok {
		r1 = returnFunc(ctx, params)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetDynamicSecretValue is a helper method to define mock.On call
//   - ctx context.Context
//   - params akeyless.GetDynamicSecretValue
func (_e *mockAkeylessAPIClient_Expecter) GetDynamicSecretValue(ctx interface{}, params interface{}) *mockAkeylessAPIClient_GetDynamicSecretValue_Call {
	return &mockAkeylessAPIClient_GetDynamicSecretValue_Call{Call: _e.mock.On("GetDynamicSecretValue", ctx, params)}
}

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

func (_c *mockAkeylessAPIClient_GetDynamicSecretValue_Call) Return(stringToV map[string]any, err error) *mockAkeylessAPIClient_GetDynamicSecretValue_Call {
	_c.Call.Return(stringToV, err)
	return _c
}

func (_c *mockAkeylessAPIClient_GetDynamicSecretValue_Call) RunAndReturn(run func(ctx context.Context, params akeyless.GetDynamicSecretValue) (map[string]any, error)) *mockAkeylessAPIClient_GetDynamicSecretValue_Call {
	_c.Call.Return(run)
	return _c
}

// GetPKICertificate provides a mock function for the type mockAkeylessAPIClient
func (_mock *mockAkeylessAPIClient) GetPKICertificate(ctx context.Context, params akeyless.GetPKICertificate) (akeyless.GetPKICertificateOutput, error) {
	ret := _mock.Called(ctx, params)

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

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

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

// GetPKICertificate is a helper method to define mock.On call
//   - ctx context.Context
//   - params akeyless.GetPKICertificate
func (_e *mockAkeylessAPIClient_Expecter) GetPKICertificate(ctx interface{}, params interface{}) *mockAkeylessAPIClient_GetPKICertificate_Call {
	return &mockAkeylessAPIClient_GetPKICertificate_Call{Call: _e.mock.On("GetPKICertificate", ctx, params)}
}

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

func (_c *mockAkeylessAPIClient_GetPKICertificate_Call) Return(getPKICertificateOutput akeyless.GetPKICertificateOutput, err error) *mockAkeylessAPIClient_GetPKICertificate_Call {
	_c.Call.Return(getPKICertificateOutput, err)
	return _c
}

func (_c *mockAkeylessAPIClient_GetPKICertificate_Call) RunAndReturn(run func(ctx context.Context, params akeyless.GetPKICertificate) (akeyless.GetPKICertificateOutput, error)) *mockAkeylessAPIClient_GetPKICertificate_Call {
	_c.Call.Return(run)
	return _c
}

// GetRotatedSecretValue provides a mock function for the type mockAkeylessAPIClient
func (_mock *mockAkeylessAPIClient) GetRotatedSecretValue(ctx context.Context, params akeyless.GetRotatedSecretValue) (map[string]any, error) {
	ret := _mock.Called(ctx, params)

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

	var r0 map[string]any
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, akeyless.GetRotatedSecretValue) (map[string]any, error)); ok {
		return returnFunc(ctx, params)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, akeyless.GetRotatedSecretValue) map[string]any); ok {
		r0 = returnFunc(ctx, params)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[string]any)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, akeyless.GetRotatedSecretValue) error); ok {
		r1 = returnFunc(ctx, params)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetRotatedSecretValue is a helper method to define mock.On call
//   - ctx context.Context
//   - params akeyless.GetRotatedSecretValue
func (_e *mockAkeylessAPIClient_Expecter) GetRotatedSecretValue(ctx interface{}, params interface{}) *mockAkeylessAPIClient_GetRotatedSecretValue_Call {
	return &mockAkeylessAPIClient_GetRotatedSecretValue_Call{Call: _e.mock.On("GetRotatedSecretValue", ctx, params)}
}

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

func (_c *mockAkeylessAPIClient_GetRotatedSecretValue_Call) Return(stringToV map[string]any, err error) *mockAkeylessAPIClient_GetRotatedSecretValue_Call {
	_c.Call.Return(stringToV, err)
	return _c
}

func (_c *mockAkeylessAPIClient_GetRotatedSecretValue_Call) RunAndReturn(run func(ctx context.Context, params akeyless.GetRotatedSecretValue) (map[string]any, error)) *mockAkeylessAPIClient_GetRotatedSecretValue_Call {
	_c.Call.Return(run)
	return _c
}

// GetSSHCertificate provides a mock function for the type mockAkeylessAPIClient
func (_mock *mockAkeylessAPIClient) GetSSHCertificate(ctx context.Context, params akeyless.GetSSHCertificate) (akeyless.GetSSHCertificateOutput, error) {
	ret := _mock.Called(ctx, params)

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

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

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

// GetSSHCertificate is a helper method to define mock.On call
//   - ctx context.Context
//   - params akeyless.GetSSHCertificate
func (_e *mockAkeylessAPIClient_Expecter) GetSSHCertificate(ctx interface{}, params interface{}) *mockAkeylessAPIClient_GetSSHCertificate_Call {
	return &mockAkeylessAPIClient_GetSSHCertificate_Call{Call: _e.mock.On("GetSSHCertificate", ctx, params)}
}

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

func (_c *mockAkeylessAPIClient_GetSSHCertificate_Call) Return(getSSHCertificateOutput akeyless.GetSSHCertificateOutput, err error) *mockAkeylessAPIClient_GetSSHCertificate_Call {
	_c.Call.Return(getSSHCertificateOutput, err)
	return _c
}

func (_c *mockAkeylessAPIClient_GetSSHCertificate_Call) RunAndReturn(run func(ctx context.Context, params akeyless.GetSSHCertificate) (akeyless.GetSSHCertificateOutput, error)) *mockAkeylessAPIClient_GetSSHCertificate_Call {
	_c.Call.Return(run)
	return _c
}

// GetSecretValue provides a mock function for the type mockAkeylessAPIClient
func (_mock *mockAkeylessAPIClient) GetSecretValue(ctx context.Context, body akeyless.GetSecretValue) (map[string]any, error) {
	ret := _mock.Called(ctx, body)

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

	var r0 map[string]any
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, akeyless.GetSecretValue) (map[string]any, error)); ok {
		return returnFunc(ctx, body)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, akeyless.GetSecretValue) map[string]any); ok {
		r0 = returnFunc(ctx, body)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[string]any)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, akeyless.GetSecretValue) error); ok {
		r1 = returnFunc(ctx, body)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetSecretValue is a helper method to define mock.On call
//   - ctx context.Context
//   - body akeyless.GetSecretValue
func (_e *mockAkeylessAPIClient_Expecter) GetSecretValue(ctx interface{}, body interface{}) *mockAkeylessAPIClient_GetSecretValue_Call {
	return &mockAkeylessAPIClient_GetSecretValue_Call{Call: _e.mock.On("GetSecretValue", ctx, body)}
}

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

func (_c *mockAkeylessAPIClient_GetSecretValue_Call) Return(stringToV map[string]any, err error) *mockAkeylessAPIClient_GetSecretValue_Call {
	_c.Call.Return(stringToV, err)
	return _c
}

func (_c *mockAkeylessAPIClient_GetSecretValue_Call) RunAndReturn(run func(ctx context.Context, body akeyless.GetSecretValue) (map[string]any, error)) *mockAkeylessAPIClient_GetSecretValue_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type MockAkeyless_Expecter struct {
	mock *mock.Mock
}

func (_m *MockAkeyless) EXPECT() *MockAkeyless_Expecter {
	return &MockAkeyless_Expecter{mock: &_m.Mock}
}

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

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

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

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

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

func (_c *MockAkeyless_GetSecret_Call) Run(run func(ctx context.Context)) *MockAkeyless_GetSecret_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 *MockAkeyless_GetSecret_Call) Return(v any, err error) *MockAkeyless_GetSecret_Call {
	_c.Call.Return(v, err)
	return _c
}

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