// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/choria-io/go-choria/inter (interfaces: SecurityProvider)
//
// Generated by this command:
//
//	mockgen -write_generate_directive -destination security.go -package imock github.com/choria-io/go-choria/inter SecurityProvider
//

// Package imock is a generated GoMock package.
package imock

import (
	context "context"
	tls "crypto/tls"
	x509 "crypto/x509"
	http "net/http"
	reflect "reflect"
	time "time"

	inter "github.com/choria-io/go-choria/inter"
	gomock "go.uber.org/mock/gomock"
)

//go:generate mockgen -write_generate_directive -destination security.go -package imock github.com/choria-io/go-choria/inter SecurityProvider

// MockSecurityProvider is a mock of SecurityProvider interface.
type MockSecurityProvider struct {
	ctrl     *gomock.Controller
	recorder *MockSecurityProviderMockRecorder
	isgomock struct{}
}

// MockSecurityProviderMockRecorder is the mock recorder for MockSecurityProvider.
type MockSecurityProviderMockRecorder struct {
	mock *MockSecurityProvider
}

// NewMockSecurityProvider creates a new mock instance.
func NewMockSecurityProvider(ctrl *gomock.Controller) *MockSecurityProvider {
	mock := &MockSecurityProvider{ctrl: ctrl}
	mock.recorder = &MockSecurityProviderMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockSecurityProvider) EXPECT() *MockSecurityProviderMockRecorder {
	return m.recorder
}

// BackingTechnology mocks base method.
func (m *MockSecurityProvider) BackingTechnology() inter.SecurityTechnology {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BackingTechnology")
	ret0, _ := ret[0].(inter.SecurityTechnology)
	return ret0
}

// BackingTechnology indicates an expected call of BackingTechnology.
func (mr *MockSecurityProviderMockRecorder) BackingTechnology() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BackingTechnology", reflect.TypeOf((*MockSecurityProvider)(nil).BackingTechnology))
}

// CallerIdentity mocks base method.
func (m *MockSecurityProvider) CallerIdentity(caller string) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CallerIdentity", caller)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CallerIdentity indicates an expected call of CallerIdentity.
func (mr *MockSecurityProviderMockRecorder) CallerIdentity(caller any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CallerIdentity", reflect.TypeOf((*MockSecurityProvider)(nil).CallerIdentity), caller)
}

// CallerName mocks base method.
func (m *MockSecurityProvider) CallerName() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CallerName")
	ret0, _ := ret[0].(string)
	return ret0
}

// CallerName indicates an expected call of CallerName.
func (mr *MockSecurityProviderMockRecorder) CallerName() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CallerName", reflect.TypeOf((*MockSecurityProvider)(nil).CallerName))
}

// ChecksumBytes mocks base method.
func (m *MockSecurityProvider) ChecksumBytes(data []byte) []byte {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ChecksumBytes", data)
	ret0, _ := ret[0].([]byte)
	return ret0
}

// ChecksumBytes indicates an expected call of ChecksumBytes.
func (mr *MockSecurityProviderMockRecorder) ChecksumBytes(data any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChecksumBytes", reflect.TypeOf((*MockSecurityProvider)(nil).ChecksumBytes), data)
}

// ClientTLSConfig mocks base method.
func (m *MockSecurityProvider) ClientTLSConfig() (*tls.Config, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClientTLSConfig")
	ret0, _ := ret[0].(*tls.Config)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ClientTLSConfig indicates an expected call of ClientTLSConfig.
func (mr *MockSecurityProviderMockRecorder) ClientTLSConfig() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientTLSConfig", reflect.TypeOf((*MockSecurityProvider)(nil).ClientTLSConfig))
}

// Enroll mocks base method.
func (m *MockSecurityProvider) Enroll(ctx context.Context, wait time.Duration, cb func(string, int)) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Enroll", ctx, wait, cb)
	ret0, _ := ret[0].(error)
	return ret0
}

// Enroll indicates an expected call of Enroll.
func (mr *MockSecurityProviderMockRecorder) Enroll(ctx, wait, cb any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Enroll", reflect.TypeOf((*MockSecurityProvider)(nil).Enroll), ctx, wait, cb)
}

// HTTPClient mocks base method.
func (m *MockSecurityProvider) HTTPClient(secure bool) (*http.Client, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HTTPClient", secure)
	ret0, _ := ret[0].(*http.Client)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HTTPClient indicates an expected call of HTTPClient.
func (mr *MockSecurityProviderMockRecorder) HTTPClient(secure any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HTTPClient", reflect.TypeOf((*MockSecurityProvider)(nil).HTTPClient), secure)
}

// Identity mocks base method.
func (m *MockSecurityProvider) Identity() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Identity")
	ret0, _ := ret[0].(string)
	return ret0
}

// Identity indicates an expected call of Identity.
func (mr *MockSecurityProviderMockRecorder) Identity() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Identity", reflect.TypeOf((*MockSecurityProvider)(nil).Identity))
}

// IsRemoteSigning mocks base method.
func (m *MockSecurityProvider) IsRemoteSigning() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsRemoteSigning")
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsRemoteSigning indicates an expected call of IsRemoteSigning.
func (mr *MockSecurityProviderMockRecorder) IsRemoteSigning() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsRemoteSigning", reflect.TypeOf((*MockSecurityProvider)(nil).IsRemoteSigning))
}

// Provider mocks base method.
func (m *MockSecurityProvider) Provider() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Provider")
	ret0, _ := ret[0].(string)
	return ret0
}

// Provider indicates an expected call of Provider.
func (mr *MockSecurityProviderMockRecorder) Provider() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Provider", reflect.TypeOf((*MockSecurityProvider)(nil).Provider))
}

// PublicCert mocks base method.
func (m *MockSecurityProvider) PublicCert() (*x509.Certificate, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PublicCert")
	ret0, _ := ret[0].(*x509.Certificate)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PublicCert indicates an expected call of PublicCert.
func (mr *MockSecurityProviderMockRecorder) PublicCert() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PublicCert", reflect.TypeOf((*MockSecurityProvider)(nil).PublicCert))
}

// PublicCertBytes mocks base method.
func (m *MockSecurityProvider) PublicCertBytes() ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PublicCertBytes")
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PublicCertBytes indicates an expected call of PublicCertBytes.
func (mr *MockSecurityProviderMockRecorder) PublicCertBytes() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PublicCertBytes", reflect.TypeOf((*MockSecurityProvider)(nil).PublicCertBytes))
}

// RemoteSignRequest mocks base method.
func (m *MockSecurityProvider) RemoteSignRequest(ctx context.Context, str []byte) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoteSignRequest", ctx, str)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RemoteSignRequest indicates an expected call of RemoteSignRequest.
func (mr *MockSecurityProviderMockRecorder) RemoteSignRequest(ctx, str any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoteSignRequest", reflect.TypeOf((*MockSecurityProvider)(nil).RemoteSignRequest), ctx, str)
}

// SSLContext mocks base method.
func (m *MockSecurityProvider) SSLContext() (*http.Transport, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SSLContext")
	ret0, _ := ret[0].(*http.Transport)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SSLContext indicates an expected call of SSLContext.
func (mr *MockSecurityProviderMockRecorder) SSLContext() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SSLContext", reflect.TypeOf((*MockSecurityProvider)(nil).SSLContext))
}

// ShouldAllowCaller mocks base method.
func (m *MockSecurityProvider) ShouldAllowCaller(name string, callers ...[]byte) (bool, error) {
	m.ctrl.T.Helper()
	varargs := []any{name}
	for _, a := range callers {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ShouldAllowCaller", varargs...)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ShouldAllowCaller indicates an expected call of ShouldAllowCaller.
func (mr *MockSecurityProviderMockRecorder) ShouldAllowCaller(name any, callers ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{name}, callers...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShouldAllowCaller", reflect.TypeOf((*MockSecurityProvider)(nil).ShouldAllowCaller), varargs...)
}

// ShouldSignReplies mocks base method.
func (m *MockSecurityProvider) ShouldSignReplies() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ShouldSignReplies")
	ret0, _ := ret[0].(bool)
	return ret0
}

// ShouldSignReplies indicates an expected call of ShouldSignReplies.
func (mr *MockSecurityProviderMockRecorder) ShouldSignReplies() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShouldSignReplies", reflect.TypeOf((*MockSecurityProvider)(nil).ShouldSignReplies))
}

// SignBytes mocks base method.
func (m *MockSecurityProvider) SignBytes(b []byte) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SignBytes", b)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SignBytes indicates an expected call of SignBytes.
func (mr *MockSecurityProviderMockRecorder) SignBytes(b any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignBytes", reflect.TypeOf((*MockSecurityProvider)(nil).SignBytes), b)
}

// TLSConfig mocks base method.
func (m *MockSecurityProvider) TLSConfig() (*tls.Config, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TLSConfig")
	ret0, _ := ret[0].(*tls.Config)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// TLSConfig indicates an expected call of TLSConfig.
func (mr *MockSecurityProviderMockRecorder) TLSConfig() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TLSConfig", reflect.TypeOf((*MockSecurityProvider)(nil).TLSConfig))
}

// TokenBytes mocks base method.
func (m *MockSecurityProvider) TokenBytes() ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TokenBytes")
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// TokenBytes indicates an expected call of TokenBytes.
func (mr *MockSecurityProviderMockRecorder) TokenBytes() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TokenBytes", reflect.TypeOf((*MockSecurityProvider)(nil).TokenBytes))
}

// Validate mocks base method.
func (m *MockSecurityProvider) Validate() ([]string, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Validate")
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// Validate indicates an expected call of Validate.
func (mr *MockSecurityProviderMockRecorder) Validate() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Validate", reflect.TypeOf((*MockSecurityProvider)(nil).Validate))
}

// VerifySignatureBytes mocks base method.
func (m *MockSecurityProvider) VerifySignatureBytes(dat, sig []byte, public ...[]byte) (bool, string) {
	m.ctrl.T.Helper()
	varargs := []any{dat, sig}
	for _, a := range public {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "VerifySignatureBytes", varargs...)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(string)
	return ret0, ret1
}

// VerifySignatureBytes indicates an expected call of VerifySignatureBytes.
func (mr *MockSecurityProviderMockRecorder) VerifySignatureBytes(dat, sig any, public ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{dat, sig}, public...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifySignatureBytes", reflect.TypeOf((*MockSecurityProvider)(nil).VerifySignatureBytes), varargs...)
}
