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

package auth

import (
	"context"
	"net/http"

	"github.com/golang-jwt/jwt/v5"
	mock "github.com/stretchr/testify/mock"
)

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

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

	return mock
}

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

type MockProvider_Expecter struct {
	mock *mock.Mock
}

func (_m *MockProvider) EXPECT() *MockProvider_Expecter {
	return &MockProvider_Expecter{mock: &_m.Mock}
}

// FindAndCreateACOCredentials provides a mock function for the type MockProvider
func (_mock *MockProvider) FindAndCreateACOCredentials(ACOID string, IPs []string) (string, error) {
	ret := _mock.Called(ACOID, IPs)

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

	var r0 string
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(string, []string) (string, error)); ok {
		return returnFunc(ACOID, IPs)
	}
	if returnFunc, ok := ret.Get(0).(func(string, []string) string); ok {
		r0 = returnFunc(ACOID, IPs)
	} else {
		r0 = ret.Get(0).(string)
	}
	if returnFunc, ok := ret.Get(1).(func(string, []string) error); ok {
		r1 = returnFunc(ACOID, IPs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// FindAndCreateACOCredentials is a helper method to define mock.On call
//   - ACOID string
//   - IPs []string
func (_e *MockProvider_Expecter) FindAndCreateACOCredentials(ACOID interface{}, IPs interface{}) *MockProvider_FindAndCreateACOCredentials_Call {
	return &MockProvider_FindAndCreateACOCredentials_Call{Call: _e.mock.On("FindAndCreateACOCredentials", ACOID, IPs)}
}

func (_c *MockProvider_FindAndCreateACOCredentials_Call) Run(run func(ACOID string, IPs []string)) *MockProvider_FindAndCreateACOCredentials_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)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockProvider_FindAndCreateACOCredentials_Call) Return(s string, err error) *MockProvider_FindAndCreateACOCredentials_Call {
	_c.Call.Return(s, err)
	return _c
}

func (_c *MockProvider_FindAndCreateACOCredentials_Call) RunAndReturn(run func(ACOID string, IPs []string) (string, error)) *MockProvider_FindAndCreateACOCredentials_Call {
	_c.Call.Return(run)
	return _c
}

// GetVersion provides a mock function for the type MockProvider
func (_mock *MockProvider) GetVersion() (string, error) {
	ret := _mock.Called()

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

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

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

// GetVersion is a helper method to define mock.On call
func (_e *MockProvider_Expecter) GetVersion() *MockProvider_GetVersion_Call {
	return &MockProvider_GetVersion_Call{Call: _e.mock.On("GetVersion")}
}

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

func (_c *MockProvider_GetVersion_Call) Return(s string, err error) *MockProvider_GetVersion_Call {
	_c.Call.Return(s, err)
	return _c
}

func (_c *MockProvider_GetVersion_Call) RunAndReturn(run func() (string, error)) *MockProvider_GetVersion_Call {
	_c.Call.Return(run)
	return _c
}

// MakeAccessToken provides a mock function for the type MockProvider
func (_mock *MockProvider) MakeAccessToken(credentials Credentials, r *http.Request) (string, error) {
	ret := _mock.Called(credentials, r)

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

	var r0 string
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(Credentials, *http.Request) (string, error)); ok {
		return returnFunc(credentials, r)
	}
	if returnFunc, ok := ret.Get(0).(func(Credentials, *http.Request) string); ok {
		r0 = returnFunc(credentials, r)
	} else {
		r0 = ret.Get(0).(string)
	}
	if returnFunc, ok := ret.Get(1).(func(Credentials, *http.Request) error); ok {
		r1 = returnFunc(credentials, r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// MakeAccessToken is a helper method to define mock.On call
//   - credentials Credentials
//   - r *http.Request
func (_e *MockProvider_Expecter) MakeAccessToken(credentials interface{}, r interface{}) *MockProvider_MakeAccessToken_Call {
	return &MockProvider_MakeAccessToken_Call{Call: _e.mock.On("MakeAccessToken", credentials, r)}
}

func (_c *MockProvider_MakeAccessToken_Call) Run(run func(credentials Credentials, r *http.Request)) *MockProvider_MakeAccessToken_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 Credentials
		if args[0] != nil {
			arg0 = args[0].(Credentials)
		}
		var arg1 *http.Request
		if args[1] != nil {
			arg1 = args[1].(*http.Request)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockProvider_MakeAccessToken_Call) Return(s string, err error) *MockProvider_MakeAccessToken_Call {
	_c.Call.Return(s, err)
	return _c
}

func (_c *MockProvider_MakeAccessToken_Call) RunAndReturn(run func(credentials Credentials, r *http.Request) (string, error)) *MockProvider_MakeAccessToken_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterSystem provides a mock function for the type MockProvider
func (_mock *MockProvider) RegisterSystem(localID string, publicKey string, groupID string, ips ...string) (Credentials, error) {
	var tmpRet mock.Arguments
	if len(ips) > 0 {
		tmpRet = _mock.Called(localID, publicKey, groupID, ips)
	} else {
		tmpRet = _mock.Called(localID, publicKey, groupID)
	}
	ret := tmpRet

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

	var r0 Credentials
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(string, string, string, ...string) (Credentials, error)); ok {
		return returnFunc(localID, publicKey, groupID, ips...)
	}
	if returnFunc, ok := ret.Get(0).(func(string, string, string, ...string) Credentials); ok {
		r0 = returnFunc(localID, publicKey, groupID, ips...)
	} else {
		r0 = ret.Get(0).(Credentials)
	}
	if returnFunc, ok := ret.Get(1).(func(string, string, string, ...string) error); ok {
		r1 = returnFunc(localID, publicKey, groupID, ips...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// RegisterSystem is a helper method to define mock.On call
//   - localID string
//   - publicKey string
//   - groupID string
//   - ips ...string
func (_e *MockProvider_Expecter) RegisterSystem(localID interface{}, publicKey interface{}, groupID interface{}, ips ...interface{}) *MockProvider_RegisterSystem_Call {
	return &MockProvider_RegisterSystem_Call{Call: _e.mock.On("RegisterSystem",
		append([]interface{}{localID, publicKey, groupID}, ips...)...)}
}

func (_c *MockProvider_RegisterSystem_Call) Run(run func(localID string, publicKey string, groupID string, ips ...string)) *MockProvider_RegisterSystem_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 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 []string
		var variadicArgs []string
		if len(args) > 3 {
			variadicArgs = args[3].([]string)
		}
		arg3 = variadicArgs
		run(
			arg0,
			arg1,
			arg2,
			arg3...,
		)
	})
	return _c
}

func (_c *MockProvider_RegisterSystem_Call) Return(credentials Credentials, err error) *MockProvider_RegisterSystem_Call {
	_c.Call.Return(credentials, err)
	return _c
}

func (_c *MockProvider_RegisterSystem_Call) RunAndReturn(run func(localID string, publicKey string, groupID string, ips ...string) (Credentials, error)) *MockProvider_RegisterSystem_Call {
	_c.Call.Return(run)
	return _c
}

// ResetSecret provides a mock function for the type MockProvider
func (_mock *MockProvider) ResetSecret(clientID string) (Credentials, error) {
	ret := _mock.Called(clientID)

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

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

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

// ResetSecret is a helper method to define mock.On call
//   - clientID string
func (_e *MockProvider_Expecter) ResetSecret(clientID interface{}) *MockProvider_ResetSecret_Call {
	return &MockProvider_ResetSecret_Call{Call: _e.mock.On("ResetSecret", clientID)}
}

func (_c *MockProvider_ResetSecret_Call) Run(run func(clientID string)) *MockProvider_ResetSecret_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 *MockProvider_ResetSecret_Call) Return(credentials Credentials, err error) *MockProvider_ResetSecret_Call {
	_c.Call.Return(credentials, err)
	return _c
}

func (_c *MockProvider_ResetSecret_Call) RunAndReturn(run func(clientID string) (Credentials, error)) *MockProvider_ResetSecret_Call {
	_c.Call.Return(run)
	return _c
}

// RevokeAccessToken provides a mock function for the type MockProvider
func (_mock *MockProvider) RevokeAccessToken(tokenString string) error {
	ret := _mock.Called(tokenString)

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

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

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

// RevokeAccessToken is a helper method to define mock.On call
//   - tokenString string
func (_e *MockProvider_Expecter) RevokeAccessToken(tokenString interface{}) *MockProvider_RevokeAccessToken_Call {
	return &MockProvider_RevokeAccessToken_Call{Call: _e.mock.On("RevokeAccessToken", tokenString)}
}

func (_c *MockProvider_RevokeAccessToken_Call) Run(run func(tokenString string)) *MockProvider_RevokeAccessToken_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 *MockProvider_RevokeAccessToken_Call) Return(err error) *MockProvider_RevokeAccessToken_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockProvider_RevokeAccessToken_Call) RunAndReturn(run func(tokenString string) error) *MockProvider_RevokeAccessToken_Call {
	_c.Call.Return(run)
	return _c
}

// RevokeSystemCredentials provides a mock function for the type MockProvider
func (_mock *MockProvider) RevokeSystemCredentials(clientID string) error {
	ret := _mock.Called(clientID)

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

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

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

// RevokeSystemCredentials is a helper method to define mock.On call
//   - clientID string
func (_e *MockProvider_Expecter) RevokeSystemCredentials(clientID interface{}) *MockProvider_RevokeSystemCredentials_Call {
	return &MockProvider_RevokeSystemCredentials_Call{Call: _e.mock.On("RevokeSystemCredentials", clientID)}
}

func (_c *MockProvider_RevokeSystemCredentials_Call) Run(run func(clientID string)) *MockProvider_RevokeSystemCredentials_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 *MockProvider_RevokeSystemCredentials_Call) Return(err error) *MockProvider_RevokeSystemCredentials_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockProvider_RevokeSystemCredentials_Call) RunAndReturn(run func(clientID string) error) *MockProvider_RevokeSystemCredentials_Call {
	_c.Call.Return(run)
	return _c
}

// VerifyToken provides a mock function for the type MockProvider
func (_mock *MockProvider) VerifyToken(ctx context.Context, tokenString string) (*jwt.Token, error) {
	ret := _mock.Called(ctx, tokenString)

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

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

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

// VerifyToken is a helper method to define mock.On call
//   - ctx context.Context
//   - tokenString string
func (_e *MockProvider_Expecter) VerifyToken(ctx interface{}, tokenString interface{}) *MockProvider_VerifyToken_Call {
	return &MockProvider_VerifyToken_Call{Call: _e.mock.On("VerifyToken", ctx, tokenString)}
}

func (_c *MockProvider_VerifyToken_Call) Run(run func(ctx context.Context, tokenString string)) *MockProvider_VerifyToken_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 *MockProvider_VerifyToken_Call) Return(token *jwt.Token, err error) *MockProvider_VerifyToken_Call {
	_c.Call.Return(token, err)
	return _c
}

func (_c *MockProvider_VerifyToken_Call) RunAndReturn(run func(ctx context.Context, tokenString string) (*jwt.Token, error)) *MockProvider_VerifyToken_Call {
	_c.Call.Return(run)
	return _c
}

// getAuthDataFromClaims provides a mock function for the type MockProvider
func (_mock *MockProvider) getAuthDataFromClaims(commonClaims *CommonClaims) (AuthData, error) {
	ret := _mock.Called(commonClaims)

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

	var r0 AuthData
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(*CommonClaims) (AuthData, error)); ok {
		return returnFunc(commonClaims)
	}
	if returnFunc, ok := ret.Get(0).(func(*CommonClaims) AuthData); ok {
		r0 = returnFunc(commonClaims)
	} else {
		r0 = ret.Get(0).(AuthData)
	}
	if returnFunc, ok := ret.Get(1).(func(*CommonClaims) error); ok {
		r1 = returnFunc(commonClaims)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// getAuthDataFromClaims is a helper method to define mock.On call
//   - commonClaims *CommonClaims
func (_e *MockProvider_Expecter) getAuthDataFromClaims(commonClaims interface{}) *MockProvider_getAuthDataFromClaims_Call {
	return &MockProvider_getAuthDataFromClaims_Call{Call: _e.mock.On("getAuthDataFromClaims", commonClaims)}
}

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

func (_c *MockProvider_getAuthDataFromClaims_Call) Return(authData AuthData, err error) *MockProvider_getAuthDataFromClaims_Call {
	_c.Call.Return(authData, err)
	return _c
}

func (_c *MockProvider_getAuthDataFromClaims_Call) RunAndReturn(run func(commonClaims *CommonClaims) (AuthData, error)) *MockProvider_getAuthDataFromClaims_Call {
	_c.Call.Return(run)
	return _c
}
