// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/choria-io/go-choria/inter (interfaces: ConfigurationProvider,ProtocolConstructor,ConnectionManager,Framework)
//
// Generated by this command:
//
//	mockgen -write_generate_directive -destination framework.go -package imock github.com/choria-io/go-choria/inter ConfigurationProvider,ProtocolConstructor,ConnectionManager,Framework
//

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

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

	build "github.com/choria-io/go-choria/build"
	config "github.com/choria-io/go-choria/config"
	inter "github.com/choria-io/go-choria/inter"
	protocol "github.com/choria-io/go-choria/protocol"
	election "github.com/choria-io/go-choria/providers/election/streams"
	governor "github.com/choria-io/go-choria/providers/governor/streams"
	kv "github.com/choria-io/go-choria/providers/kv"
	srvcache "github.com/choria-io/go-choria/srvcache"
	nats "github.com/nats-io/nats.go"
	logrus "github.com/sirupsen/logrus"
	gomock "go.uber.org/mock/gomock"
)

//go:generate mockgen -write_generate_directive -destination framework.go -package imock github.com/choria-io/go-choria/inter ConfigurationProvider,ProtocolConstructor,ConnectionManager,Framework

// MockConfigurationProvider is a mock of ConfigurationProvider interface.
type MockConfigurationProvider struct {
	ctrl     *gomock.Controller
	recorder *MockConfigurationProviderMockRecorder
	isgomock struct{}
}

// MockConfigurationProviderMockRecorder is the mock recorder for MockConfigurationProvider.
type MockConfigurationProviderMockRecorder struct {
	mock *MockConfigurationProvider
}

// NewMockConfigurationProvider creates a new mock instance.
func NewMockConfigurationProvider(ctrl *gomock.Controller) *MockConfigurationProvider {
	mock := &MockConfigurationProvider{ctrl: ctrl}
	mock.recorder = &MockConfigurationProviderMockRecorder{mock}
	return mock
}

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

// Configuration mocks base method.
func (m *MockConfigurationProvider) Configuration() *config.Config {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Configuration")
	ret0, _ := ret[0].(*config.Config)
	return ret0
}

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

// MockProtocolConstructor is a mock of ProtocolConstructor interface.
type MockProtocolConstructor struct {
	ctrl     *gomock.Controller
	recorder *MockProtocolConstructorMockRecorder
	isgomock struct{}
}

// MockProtocolConstructorMockRecorder is the mock recorder for MockProtocolConstructor.
type MockProtocolConstructorMockRecorder struct {
	mock *MockProtocolConstructor
}

// NewMockProtocolConstructor creates a new mock instance.
func NewMockProtocolConstructor(ctrl *gomock.Controller) *MockProtocolConstructor {
	mock := &MockProtocolConstructor{ctrl: ctrl}
	mock.recorder = &MockProtocolConstructorMockRecorder{mock}
	return mock
}

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

// NewMessage mocks base method.
func (m *MockProtocolConstructor) NewMessage(payload []byte, agent, collective, msgType string, request inter.Message) (inter.Message, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewMessage", payload, agent, collective, msgType, request)
	ret0, _ := ret[0].(inter.Message)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewMessage indicates an expected call of NewMessage.
func (mr *MockProtocolConstructorMockRecorder) NewMessage(payload, agent, collective, msgType, request any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewMessage", reflect.TypeOf((*MockProtocolConstructor)(nil).NewMessage), payload, agent, collective, msgType, request)
}

// NewMessageFromRequest mocks base method.
func (m *MockProtocolConstructor) NewMessageFromRequest(req protocol.Request, replyto string) (inter.Message, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewMessageFromRequest", req, replyto)
	ret0, _ := ret[0].(inter.Message)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewMessageFromRequest indicates an expected call of NewMessageFromRequest.
func (mr *MockProtocolConstructorMockRecorder) NewMessageFromRequest(req, replyto any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewMessageFromRequest", reflect.TypeOf((*MockProtocolConstructor)(nil).NewMessageFromRequest), req, replyto)
}

// NewReply mocks base method.
func (m *MockProtocolConstructor) NewReply(request protocol.Request) (protocol.Reply, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewReply", request)
	ret0, _ := ret[0].(protocol.Reply)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewReply indicates an expected call of NewReply.
func (mr *MockProtocolConstructorMockRecorder) NewReply(request any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewReply", reflect.TypeOf((*MockProtocolConstructor)(nil).NewReply), request)
}

// NewReplyFromMessage mocks base method.
func (m *MockProtocolConstructor) NewReplyFromMessage(version protocol.ProtocolVersion, msg inter.Message) (protocol.Reply, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewReplyFromMessage", version, msg)
	ret0, _ := ret[0].(protocol.Reply)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewReplyFromMessage indicates an expected call of NewReplyFromMessage.
func (mr *MockProtocolConstructorMockRecorder) NewReplyFromMessage(version, msg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewReplyFromMessage", reflect.TypeOf((*MockProtocolConstructor)(nil).NewReplyFromMessage), version, msg)
}

// NewReplyFromSecureReply mocks base method.
func (m *MockProtocolConstructor) NewReplyFromSecureReply(sr protocol.SecureReply) (protocol.Reply, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewReplyFromSecureReply", sr)
	ret0, _ := ret[0].(protocol.Reply)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewReplyFromSecureReply indicates an expected call of NewReplyFromSecureReply.
func (mr *MockProtocolConstructorMockRecorder) NewReplyFromSecureReply(sr any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewReplyFromSecureReply", reflect.TypeOf((*MockProtocolConstructor)(nil).NewReplyFromSecureReply), sr)
}

// NewReplyFromTransportJSON mocks base method.
func (m *MockProtocolConstructor) NewReplyFromTransportJSON(payload []byte, skipvalidate bool) (protocol.Reply, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewReplyFromTransportJSON", payload, skipvalidate)
	ret0, _ := ret[0].(protocol.Reply)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewReplyFromTransportJSON indicates an expected call of NewReplyFromTransportJSON.
func (mr *MockProtocolConstructorMockRecorder) NewReplyFromTransportJSON(payload, skipvalidate any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewReplyFromTransportJSON", reflect.TypeOf((*MockProtocolConstructor)(nil).NewReplyFromTransportJSON), payload, skipvalidate)
}

// NewReplyTransportForMessage mocks base method.
func (m *MockProtocolConstructor) NewReplyTransportForMessage(msg inter.Message, request protocol.Request) (protocol.TransportMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewReplyTransportForMessage", msg, request)
	ret0, _ := ret[0].(protocol.TransportMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewReplyTransportForMessage indicates an expected call of NewReplyTransportForMessage.
func (mr *MockProtocolConstructorMockRecorder) NewReplyTransportForMessage(msg, request any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewReplyTransportForMessage", reflect.TypeOf((*MockProtocolConstructor)(nil).NewReplyTransportForMessage), msg, request)
}

// NewRequest mocks base method.
func (m *MockProtocolConstructor) NewRequest(version protocol.ProtocolVersion, agent, senderid, callerid string, ttl int, requestid, collective string) (protocol.Request, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewRequest", version, agent, senderid, callerid, ttl, requestid, collective)
	ret0, _ := ret[0].(protocol.Request)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewRequest indicates an expected call of NewRequest.
func (mr *MockProtocolConstructorMockRecorder) NewRequest(version, agent, senderid, callerid, ttl, requestid, collective any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewRequest", reflect.TypeOf((*MockProtocolConstructor)(nil).NewRequest), version, agent, senderid, callerid, ttl, requestid, collective)
}

// NewRequestFromMessage mocks base method.
func (m *MockProtocolConstructor) NewRequestFromMessage(version protocol.ProtocolVersion, msg inter.Message) (protocol.Request, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewRequestFromMessage", version, msg)
	ret0, _ := ret[0].(protocol.Request)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewRequestFromMessage indicates an expected call of NewRequestFromMessage.
func (mr *MockProtocolConstructorMockRecorder) NewRequestFromMessage(version, msg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewRequestFromMessage", reflect.TypeOf((*MockProtocolConstructor)(nil).NewRequestFromMessage), version, msg)
}

// NewRequestFromSecureRequest mocks base method.
func (m *MockProtocolConstructor) NewRequestFromSecureRequest(sr protocol.SecureRequest) (protocol.Request, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewRequestFromSecureRequest", sr)
	ret0, _ := ret[0].(protocol.Request)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewRequestFromSecureRequest indicates an expected call of NewRequestFromSecureRequest.
func (mr *MockProtocolConstructorMockRecorder) NewRequestFromSecureRequest(sr any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewRequestFromSecureRequest", reflect.TypeOf((*MockProtocolConstructor)(nil).NewRequestFromSecureRequest), sr)
}

// NewRequestFromTransportJSON mocks base method.
func (m *MockProtocolConstructor) NewRequestFromTransportJSON(payload []byte, skipvalidate bool) (protocol.Request, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewRequestFromTransportJSON", payload, skipvalidate)
	ret0, _ := ret[0].(protocol.Request)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewRequestFromTransportJSON indicates an expected call of NewRequestFromTransportJSON.
func (mr *MockProtocolConstructorMockRecorder) NewRequestFromTransportJSON(payload, skipvalidate any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewRequestFromTransportJSON", reflect.TypeOf((*MockProtocolConstructor)(nil).NewRequestFromTransportJSON), payload, skipvalidate)
}

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

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

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

// NewRequestMessageFromTransportJSON indicates an expected call of NewRequestMessageFromTransportJSON.
func (mr *MockProtocolConstructorMockRecorder) NewRequestMessageFromTransportJSON(payload any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewRequestMessageFromTransportJSON", reflect.TypeOf((*MockProtocolConstructor)(nil).NewRequestMessageFromTransportJSON), payload)
}

// NewRequestTransportForMessage mocks base method.
func (m *MockProtocolConstructor) NewRequestTransportForMessage(ctx context.Context, msg inter.Message, version protocol.ProtocolVersion) (protocol.TransportMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewRequestTransportForMessage", ctx, msg, version)
	ret0, _ := ret[0].(protocol.TransportMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewRequestTransportForMessage indicates an expected call of NewRequestTransportForMessage.
func (mr *MockProtocolConstructorMockRecorder) NewRequestTransportForMessage(ctx, msg, version any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewRequestTransportForMessage", reflect.TypeOf((*MockProtocolConstructor)(nil).NewRequestTransportForMessage), ctx, msg, version)
}

// NewSecureReply mocks base method.
func (m *MockProtocolConstructor) NewSecureReply(reply protocol.Reply) (protocol.SecureReply, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewSecureReply", reply)
	ret0, _ := ret[0].(protocol.SecureReply)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewSecureReply indicates an expected call of NewSecureReply.
func (mr *MockProtocolConstructorMockRecorder) NewSecureReply(reply any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewSecureReply", reflect.TypeOf((*MockProtocolConstructor)(nil).NewSecureReply), reply)
}

// NewSecureReplyFromTransport mocks base method.
func (m *MockProtocolConstructor) NewSecureReplyFromTransport(message protocol.TransportMessage, skipvalidate bool) (protocol.SecureReply, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewSecureReplyFromTransport", message, skipvalidate)
	ret0, _ := ret[0].(protocol.SecureReply)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewSecureReplyFromTransport indicates an expected call of NewSecureReplyFromTransport.
func (mr *MockProtocolConstructorMockRecorder) NewSecureReplyFromTransport(message, skipvalidate any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewSecureReplyFromTransport", reflect.TypeOf((*MockProtocolConstructor)(nil).NewSecureReplyFromTransport), message, skipvalidate)
}

// NewSecureRequest mocks base method.
func (m *MockProtocolConstructor) NewSecureRequest(ctx context.Context, request protocol.Request) (protocol.SecureRequest, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewSecureRequest", ctx, request)
	ret0, _ := ret[0].(protocol.SecureRequest)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewSecureRequest indicates an expected call of NewSecureRequest.
func (mr *MockProtocolConstructorMockRecorder) NewSecureRequest(ctx, request any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewSecureRequest", reflect.TypeOf((*MockProtocolConstructor)(nil).NewSecureRequest), ctx, request)
}

// NewSecureRequestFromTransport mocks base method.
func (m *MockProtocolConstructor) NewSecureRequestFromTransport(message protocol.TransportMessage, skipvalidate bool) (protocol.SecureRequest, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewSecureRequestFromTransport", message, skipvalidate)
	ret0, _ := ret[0].(protocol.SecureRequest)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewSecureRequestFromTransport indicates an expected call of NewSecureRequestFromTransport.
func (mr *MockProtocolConstructorMockRecorder) NewSecureRequestFromTransport(message, skipvalidate any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewSecureRequestFromTransport", reflect.TypeOf((*MockProtocolConstructor)(nil).NewSecureRequestFromTransport), message, skipvalidate)
}

// NewTransportForSecureReply mocks base method.
func (m *MockProtocolConstructor) NewTransportForSecureReply(reply protocol.SecureReply) (protocol.TransportMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewTransportForSecureReply", reply)
	ret0, _ := ret[0].(protocol.TransportMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewTransportForSecureReply indicates an expected call of NewTransportForSecureReply.
func (mr *MockProtocolConstructorMockRecorder) NewTransportForSecureReply(reply any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewTransportForSecureReply", reflect.TypeOf((*MockProtocolConstructor)(nil).NewTransportForSecureReply), reply)
}

// NewTransportForSecureRequest mocks base method.
func (m *MockProtocolConstructor) NewTransportForSecureRequest(request protocol.SecureRequest) (protocol.TransportMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewTransportForSecureRequest", request)
	ret0, _ := ret[0].(protocol.TransportMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewTransportForSecureRequest indicates an expected call of NewTransportForSecureRequest.
func (mr *MockProtocolConstructorMockRecorder) NewTransportForSecureRequest(request any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewTransportForSecureRequest", reflect.TypeOf((*MockProtocolConstructor)(nil).NewTransportForSecureRequest), request)
}

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

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

// NewTransportMessage mocks base method.
func (m *MockProtocolConstructor) NewTransportMessage(version protocol.ProtocolVersion) (protocol.TransportMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewTransportMessage", version)
	ret0, _ := ret[0].(protocol.TransportMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewTransportMessage indicates an expected call of NewTransportMessage.
func (mr *MockProtocolConstructorMockRecorder) NewTransportMessage(version any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewTransportMessage", reflect.TypeOf((*MockProtocolConstructor)(nil).NewTransportMessage), version)
}

// RequestProtocol mocks base method.
func (m *MockProtocolConstructor) RequestProtocol() protocol.ProtocolVersion {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RequestProtocol")
	ret0, _ := ret[0].(protocol.ProtocolVersion)
	return ret0
}

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

// MockConnectionManager is a mock of ConnectionManager interface.
type MockConnectionManager struct {
	ctrl     *gomock.Controller
	recorder *MockConnectionManagerMockRecorder
	isgomock struct{}
}

// MockConnectionManagerMockRecorder is the mock recorder for MockConnectionManager.
type MockConnectionManagerMockRecorder struct {
	mock *MockConnectionManager
}

// NewMockConnectionManager creates a new mock instance.
func NewMockConnectionManager(ctrl *gomock.Controller) *MockConnectionManager {
	mock := &MockConnectionManager{ctrl: ctrl}
	mock.recorder = &MockConnectionManagerMockRecorder{mock}
	return mock
}

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

// NewConnector mocks base method.
func (m *MockConnectionManager) NewConnector(ctx context.Context, servers func() (srvcache.Servers, error), name string, logger *logrus.Entry) (inter.Connector, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewConnector", ctx, servers, name, logger)
	ret0, _ := ret[0].(inter.Connector)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewConnector indicates an expected call of NewConnector.
func (mr *MockConnectionManagerMockRecorder) NewConnector(ctx, servers, name, logger any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewConnector", reflect.TypeOf((*MockConnectionManager)(nil).NewConnector), ctx, servers, name, logger)
}

// MockFramework is a mock of Framework interface.
type MockFramework struct {
	ctrl     *gomock.Controller
	recorder *MockFrameworkMockRecorder
	isgomock struct{}
}

// MockFrameworkMockRecorder is the mock recorder for MockFramework.
type MockFrameworkMockRecorder struct {
	mock *MockFramework
}

// NewMockFramework creates a new mock instance.
func NewMockFramework(ctrl *gomock.Controller) *MockFramework {
	mock := &MockFramework{ctrl: ctrl}
	mock.recorder = &MockFrameworkMockRecorder{mock}
	return mock
}

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

// BuildInfo mocks base method.
func (m *MockFramework) BuildInfo() *build.Info {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BuildInfo")
	ret0, _ := ret[0].(*build.Info)
	return ret0
}

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

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

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

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

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

// ClientTLSConfig mocks base method.
func (m *MockFramework) 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 *MockFrameworkMockRecorder) ClientTLSConfig() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientTLSConfig", reflect.TypeOf((*MockFramework)(nil).ClientTLSConfig))
}

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

// Colorize indicates an expected call of Colorize.
func (mr *MockFrameworkMockRecorder) Colorize(c, st any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Colorize", reflect.TypeOf((*MockFramework)(nil).Colorize), c, st)
}

// Colorizef mocks base method.
func (m *MockFramework) Colorizef(c, format string, a ...any) string {
	m.ctrl.T.Helper()
	varargs := []any{c, format}
	for _, a_2 := range a {
		varargs = append(varargs, a_2)
	}
	ret := m.ctrl.Call(m, "Colorizef", varargs...)
	ret0, _ := ret[0].(string)
	return ret0
}

// Colorizef indicates an expected call of Colorizef.
func (mr *MockFrameworkMockRecorder) Colorizef(c, format any, a ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{c, format}, a...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Colorizef", reflect.TypeOf((*MockFramework)(nil).Colorizef), varargs...)
}

// Configuration mocks base method.
func (m *MockFramework) Configuration() *config.Config {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Configuration")
	ret0, _ := ret[0].(*config.Config)
	return ret0
}

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

// ConfigureProvisioning mocks base method.
func (m *MockFramework) ConfigureProvisioning(ctx context.Context) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ConfigureProvisioning", ctx)
}

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

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

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

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

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

// Enroll mocks base method.
func (m *MockFramework) 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 *MockFrameworkMockRecorder) Enroll(ctx, wait, cb any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Enroll", reflect.TypeOf((*MockFramework)(nil).Enroll), ctx, wait, cb)
}

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

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

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

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

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

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

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

// FacterStringFact indicates an expected call of FacterStringFact.
func (mr *MockFrameworkMockRecorder) FacterStringFact(fact any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FacterStringFact", reflect.TypeOf((*MockFramework)(nil).FacterStringFact), fact)
}

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

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

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

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

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

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

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

// GovernorSubject indicates an expected call of GovernorSubject.
func (mr *MockFrameworkMockRecorder) GovernorSubject(name any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GovernorSubject", reflect.TypeOf((*MockFramework)(nil).GovernorSubject), name)
}

// HTTPClient mocks base method.
func (m *MockFramework) 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 *MockFrameworkMockRecorder) HTTPClient(secure any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HTTPClient", reflect.TypeOf((*MockFramework)(nil).HTTPClient), secure)
}

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

// HasCollective indicates an expected call of HasCollective.
func (mr *MockFrameworkMockRecorder) HasCollective(collective any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasCollective", reflect.TypeOf((*MockFramework)(nil).HasCollective), collective)
}

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

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

// KV mocks base method.
func (m *MockFramework) KV(ctx context.Context, conn inter.Connector, bucket string, create bool, opts ...kv.Option) (nats.KeyValue, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, conn, bucket, create}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "KV", varargs...)
	ret0, _ := ret[0].(nats.KeyValue)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// KV indicates an expected call of KV.
func (mr *MockFrameworkMockRecorder) KV(ctx, conn, bucket, create any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, conn, bucket, create}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "KV", reflect.TypeOf((*MockFramework)(nil).KV), varargs...)
}

// KVWithConn mocks base method.
func (m *MockFramework) KVWithConn(ctx context.Context, conn inter.Connector, bucket string, create bool, opts ...kv.Option) (nats.KeyValue, inter.Connector, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, conn, bucket, create}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "KVWithConn", varargs...)
	ret0, _ := ret[0].(nats.KeyValue)
	ret1, _ := ret[1].(inter.Connector)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// KVWithConn indicates an expected call of KVWithConn.
func (mr *MockFrameworkMockRecorder) KVWithConn(ctx, conn, bucket, create any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, conn, bucket, create}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "KVWithConn", reflect.TypeOf((*MockFramework)(nil).KVWithConn), varargs...)
}

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

// Logger indicates an expected call of Logger.
func (mr *MockFrameworkMockRecorder) Logger(component any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Logger", reflect.TypeOf((*MockFramework)(nil).Logger), component)
}

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

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

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

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

// NewConnector mocks base method.
func (m *MockFramework) NewConnector(ctx context.Context, servers func() (srvcache.Servers, error), name string, logger *logrus.Entry) (inter.Connector, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewConnector", ctx, servers, name, logger)
	ret0, _ := ret[0].(inter.Connector)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewConnector indicates an expected call of NewConnector.
func (mr *MockFrameworkMockRecorder) NewConnector(ctx, servers, name, logger any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewConnector", reflect.TypeOf((*MockFramework)(nil).NewConnector), ctx, servers, name, logger)
}

// NewElection mocks base method.
func (m *MockFramework) NewElection(ctx context.Context, conn inter.Connector, name string, imported bool, opts ...election.Option) (inter.Election, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, conn, name, imported}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "NewElection", varargs...)
	ret0, _ := ret[0].(inter.Election)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewElection indicates an expected call of NewElection.
func (mr *MockFrameworkMockRecorder) NewElection(ctx, conn, name, imported any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, conn, name, imported}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewElection", reflect.TypeOf((*MockFramework)(nil).NewElection), varargs...)
}

// NewElectionWithConn mocks base method.
func (m *MockFramework) NewElectionWithConn(ctx context.Context, conn inter.Connector, name string, imported bool, opts ...election.Option) (inter.Election, inter.Connector, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, conn, name, imported}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "NewElectionWithConn", varargs...)
	ret0, _ := ret[0].(inter.Election)
	ret1, _ := ret[1].(inter.Connector)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// NewElectionWithConn indicates an expected call of NewElectionWithConn.
func (mr *MockFrameworkMockRecorder) NewElectionWithConn(ctx, conn, name, imported any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, conn, name, imported}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewElectionWithConn", reflect.TypeOf((*MockFramework)(nil).NewElectionWithConn), varargs...)
}

// NewGovernor mocks base method.
func (m *MockFramework) NewGovernor(ctx context.Context, name string, conn inter.Connector, opts ...governor.Option) (governor.Governor, inter.Connector, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, name, conn}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "NewGovernor", varargs...)
	ret0, _ := ret[0].(governor.Governor)
	ret1, _ := ret[1].(inter.Connector)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// NewGovernor indicates an expected call of NewGovernor.
func (mr *MockFrameworkMockRecorder) NewGovernor(ctx, name, conn any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, name, conn}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewGovernor", reflect.TypeOf((*MockFramework)(nil).NewGovernor), varargs...)
}

// NewGovernorManager mocks base method.
func (m *MockFramework) NewGovernorManager(ctx context.Context, name string, limit uint64, maxAge time.Duration, replicas uint, update bool, conn inter.Connector, opts ...governor.Option) (governor.Manager, inter.Connector, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, name, limit, maxAge, replicas, update, conn}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "NewGovernorManager", varargs...)
	ret0, _ := ret[0].(governor.Manager)
	ret1, _ := ret[1].(inter.Connector)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// NewGovernorManager indicates an expected call of NewGovernorManager.
func (mr *MockFrameworkMockRecorder) NewGovernorManager(ctx, name, limit, maxAge, replicas, update, conn any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, name, limit, maxAge, replicas, update, conn}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewGovernorManager", reflect.TypeOf((*MockFramework)(nil).NewGovernorManager), varargs...)
}

// NewMessage mocks base method.
func (m *MockFramework) NewMessage(payload []byte, agent, collective, msgType string, request inter.Message) (inter.Message, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewMessage", payload, agent, collective, msgType, request)
	ret0, _ := ret[0].(inter.Message)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewMessage indicates an expected call of NewMessage.
func (mr *MockFrameworkMockRecorder) NewMessage(payload, agent, collective, msgType, request any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewMessage", reflect.TypeOf((*MockFramework)(nil).NewMessage), payload, agent, collective, msgType, request)
}

// NewMessageFromRequest mocks base method.
func (m *MockFramework) NewMessageFromRequest(req protocol.Request, replyto string) (inter.Message, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewMessageFromRequest", req, replyto)
	ret0, _ := ret[0].(inter.Message)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewMessageFromRequest indicates an expected call of NewMessageFromRequest.
func (mr *MockFrameworkMockRecorder) NewMessageFromRequest(req, replyto any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewMessageFromRequest", reflect.TypeOf((*MockFramework)(nil).NewMessageFromRequest), req, replyto)
}

// NewReply mocks base method.
func (m *MockFramework) NewReply(request protocol.Request) (protocol.Reply, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewReply", request)
	ret0, _ := ret[0].(protocol.Reply)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewReply indicates an expected call of NewReply.
func (mr *MockFrameworkMockRecorder) NewReply(request any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewReply", reflect.TypeOf((*MockFramework)(nil).NewReply), request)
}

// NewReplyFromMessage mocks base method.
func (m *MockFramework) NewReplyFromMessage(version protocol.ProtocolVersion, msg inter.Message) (protocol.Reply, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewReplyFromMessage", version, msg)
	ret0, _ := ret[0].(protocol.Reply)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewReplyFromMessage indicates an expected call of NewReplyFromMessage.
func (mr *MockFrameworkMockRecorder) NewReplyFromMessage(version, msg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewReplyFromMessage", reflect.TypeOf((*MockFramework)(nil).NewReplyFromMessage), version, msg)
}

// NewReplyFromSecureReply mocks base method.
func (m *MockFramework) NewReplyFromSecureReply(sr protocol.SecureReply) (protocol.Reply, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewReplyFromSecureReply", sr)
	ret0, _ := ret[0].(protocol.Reply)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewReplyFromSecureReply indicates an expected call of NewReplyFromSecureReply.
func (mr *MockFrameworkMockRecorder) NewReplyFromSecureReply(sr any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewReplyFromSecureReply", reflect.TypeOf((*MockFramework)(nil).NewReplyFromSecureReply), sr)
}

// NewReplyFromTransportJSON mocks base method.
func (m *MockFramework) NewReplyFromTransportJSON(payload []byte, skipvalidate bool) (protocol.Reply, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewReplyFromTransportJSON", payload, skipvalidate)
	ret0, _ := ret[0].(protocol.Reply)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewReplyFromTransportJSON indicates an expected call of NewReplyFromTransportJSON.
func (mr *MockFrameworkMockRecorder) NewReplyFromTransportJSON(payload, skipvalidate any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewReplyFromTransportJSON", reflect.TypeOf((*MockFramework)(nil).NewReplyFromTransportJSON), payload, skipvalidate)
}

// NewReplyTransportForMessage mocks base method.
func (m *MockFramework) NewReplyTransportForMessage(msg inter.Message, request protocol.Request) (protocol.TransportMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewReplyTransportForMessage", msg, request)
	ret0, _ := ret[0].(protocol.TransportMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewReplyTransportForMessage indicates an expected call of NewReplyTransportForMessage.
func (mr *MockFrameworkMockRecorder) NewReplyTransportForMessage(msg, request any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewReplyTransportForMessage", reflect.TypeOf((*MockFramework)(nil).NewReplyTransportForMessage), msg, request)
}

// NewRequest mocks base method.
func (m *MockFramework) NewRequest(version protocol.ProtocolVersion, agent, senderid, callerid string, ttl int, requestid, collective string) (protocol.Request, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewRequest", version, agent, senderid, callerid, ttl, requestid, collective)
	ret0, _ := ret[0].(protocol.Request)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewRequest indicates an expected call of NewRequest.
func (mr *MockFrameworkMockRecorder) NewRequest(version, agent, senderid, callerid, ttl, requestid, collective any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewRequest", reflect.TypeOf((*MockFramework)(nil).NewRequest), version, agent, senderid, callerid, ttl, requestid, collective)
}

// NewRequestFromMessage mocks base method.
func (m *MockFramework) NewRequestFromMessage(version protocol.ProtocolVersion, msg inter.Message) (protocol.Request, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewRequestFromMessage", version, msg)
	ret0, _ := ret[0].(protocol.Request)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewRequestFromMessage indicates an expected call of NewRequestFromMessage.
func (mr *MockFrameworkMockRecorder) NewRequestFromMessage(version, msg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewRequestFromMessage", reflect.TypeOf((*MockFramework)(nil).NewRequestFromMessage), version, msg)
}

// NewRequestFromSecureRequest mocks base method.
func (m *MockFramework) NewRequestFromSecureRequest(sr protocol.SecureRequest) (protocol.Request, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewRequestFromSecureRequest", sr)
	ret0, _ := ret[0].(protocol.Request)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewRequestFromSecureRequest indicates an expected call of NewRequestFromSecureRequest.
func (mr *MockFrameworkMockRecorder) NewRequestFromSecureRequest(sr any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewRequestFromSecureRequest", reflect.TypeOf((*MockFramework)(nil).NewRequestFromSecureRequest), sr)
}

// NewRequestFromTransportJSON mocks base method.
func (m *MockFramework) NewRequestFromTransportJSON(payload []byte, skipvalidate bool) (protocol.Request, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewRequestFromTransportJSON", payload, skipvalidate)
	ret0, _ := ret[0].(protocol.Request)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewRequestFromTransportJSON indicates an expected call of NewRequestFromTransportJSON.
func (mr *MockFrameworkMockRecorder) NewRequestFromTransportJSON(payload, skipvalidate any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewRequestFromTransportJSON", reflect.TypeOf((*MockFramework)(nil).NewRequestFromTransportJSON), payload, skipvalidate)
}

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

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

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

// NewRequestMessageFromTransportJSON indicates an expected call of NewRequestMessageFromTransportJSON.
func (mr *MockFrameworkMockRecorder) NewRequestMessageFromTransportJSON(payload any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewRequestMessageFromTransportJSON", reflect.TypeOf((*MockFramework)(nil).NewRequestMessageFromTransportJSON), payload)
}

// NewRequestTransportForMessage mocks base method.
func (m *MockFramework) NewRequestTransportForMessage(ctx context.Context, msg inter.Message, version protocol.ProtocolVersion) (protocol.TransportMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewRequestTransportForMessage", ctx, msg, version)
	ret0, _ := ret[0].(protocol.TransportMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewRequestTransportForMessage indicates an expected call of NewRequestTransportForMessage.
func (mr *MockFrameworkMockRecorder) NewRequestTransportForMessage(ctx, msg, version any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewRequestTransportForMessage", reflect.TypeOf((*MockFramework)(nil).NewRequestTransportForMessage), ctx, msg, version)
}

// NewSecureReply mocks base method.
func (m *MockFramework) NewSecureReply(reply protocol.Reply) (protocol.SecureReply, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewSecureReply", reply)
	ret0, _ := ret[0].(protocol.SecureReply)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewSecureReply indicates an expected call of NewSecureReply.
func (mr *MockFrameworkMockRecorder) NewSecureReply(reply any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewSecureReply", reflect.TypeOf((*MockFramework)(nil).NewSecureReply), reply)
}

// NewSecureReplyFromTransport mocks base method.
func (m *MockFramework) NewSecureReplyFromTransport(message protocol.TransportMessage, skipvalidate bool) (protocol.SecureReply, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewSecureReplyFromTransport", message, skipvalidate)
	ret0, _ := ret[0].(protocol.SecureReply)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewSecureReplyFromTransport indicates an expected call of NewSecureReplyFromTransport.
func (mr *MockFrameworkMockRecorder) NewSecureReplyFromTransport(message, skipvalidate any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewSecureReplyFromTransport", reflect.TypeOf((*MockFramework)(nil).NewSecureReplyFromTransport), message, skipvalidate)
}

// NewSecureRequest mocks base method.
func (m *MockFramework) NewSecureRequest(ctx context.Context, request protocol.Request) (protocol.SecureRequest, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewSecureRequest", ctx, request)
	ret0, _ := ret[0].(protocol.SecureRequest)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewSecureRequest indicates an expected call of NewSecureRequest.
func (mr *MockFrameworkMockRecorder) NewSecureRequest(ctx, request any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewSecureRequest", reflect.TypeOf((*MockFramework)(nil).NewSecureRequest), ctx, request)
}

// NewSecureRequestFromTransport mocks base method.
func (m *MockFramework) NewSecureRequestFromTransport(message protocol.TransportMessage, skipvalidate bool) (protocol.SecureRequest, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewSecureRequestFromTransport", message, skipvalidate)
	ret0, _ := ret[0].(protocol.SecureRequest)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewSecureRequestFromTransport indicates an expected call of NewSecureRequestFromTransport.
func (mr *MockFrameworkMockRecorder) NewSecureRequestFromTransport(message, skipvalidate any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewSecureRequestFromTransport", reflect.TypeOf((*MockFramework)(nil).NewSecureRequestFromTransport), message, skipvalidate)
}

// NewTransportForSecureReply mocks base method.
func (m *MockFramework) NewTransportForSecureReply(reply protocol.SecureReply) (protocol.TransportMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewTransportForSecureReply", reply)
	ret0, _ := ret[0].(protocol.TransportMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewTransportForSecureReply indicates an expected call of NewTransportForSecureReply.
func (mr *MockFrameworkMockRecorder) NewTransportForSecureReply(reply any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewTransportForSecureReply", reflect.TypeOf((*MockFramework)(nil).NewTransportForSecureReply), reply)
}

// NewTransportForSecureRequest mocks base method.
func (m *MockFramework) NewTransportForSecureRequest(request protocol.SecureRequest) (protocol.TransportMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewTransportForSecureRequest", request)
	ret0, _ := ret[0].(protocol.TransportMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewTransportForSecureRequest indicates an expected call of NewTransportForSecureRequest.
func (mr *MockFrameworkMockRecorder) NewTransportForSecureRequest(request any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewTransportForSecureRequest", reflect.TypeOf((*MockFramework)(nil).NewTransportForSecureRequest), request)
}

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

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

// NewTransportMessage mocks base method.
func (m *MockFramework) NewTransportMessage(version protocol.ProtocolVersion) (protocol.TransportMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewTransportMessage", version)
	ret0, _ := ret[0].(protocol.TransportMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewTransportMessage indicates an expected call of NewTransportMessage.
func (mr *MockFrameworkMockRecorder) NewTransportMessage(version any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewTransportMessage", reflect.TypeOf((*MockFramework)(nil).NewTransportMessage), version)
}

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

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

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

// PQLQuery indicates an expected call of PQLQuery.
func (mr *MockFrameworkMockRecorder) PQLQuery(query any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PQLQuery", reflect.TypeOf((*MockFramework)(nil).PQLQuery), query)
}

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

// PQLQueryCertNames indicates an expected call of PQLQueryCertNames.
func (mr *MockFrameworkMockRecorder) PQLQueryCertNames(query any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PQLQueryCertNames", reflect.TypeOf((*MockFramework)(nil).PQLQueryCertNames), query)
}

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

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

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

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

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

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

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

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

// PublicCert mocks base method.
func (m *MockFramework) 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 *MockFrameworkMockRecorder) PublicCert() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PublicCert", reflect.TypeOf((*MockFramework)(nil).PublicCert))
}

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

// PuppetAIOCmd indicates an expected call of PuppetAIOCmd.
func (mr *MockFrameworkMockRecorder) PuppetAIOCmd(command, def any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PuppetAIOCmd", reflect.TypeOf((*MockFramework)(nil).PuppetAIOCmd), command, def)
}

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

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

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

// PuppetSetting indicates an expected call of PuppetSetting.
func (mr *MockFrameworkMockRecorder) PuppetSetting(setting any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PuppetSetting", reflect.TypeOf((*MockFramework)(nil).PuppetSetting), setting)
}

// QuerySrvRecords mocks base method.
func (m *MockFramework) QuerySrvRecords(records []string) (srvcache.Servers, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QuerySrvRecords", records)
	ret0, _ := ret[0].(srvcache.Servers)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// QuerySrvRecords indicates an expected call of QuerySrvRecords.
func (mr *MockFrameworkMockRecorder) QuerySrvRecords(records any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QuerySrvRecords", reflect.TypeOf((*MockFramework)(nil).QuerySrvRecords), records)
}

// RequestProtocol mocks base method.
func (m *MockFramework) RequestProtocol() protocol.ProtocolVersion {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RequestProtocol")
	ret0, _ := ret[0].(protocol.ProtocolVersion)
	return ret0
}

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

// SetLogWriter mocks base method.
func (m *MockFramework) SetLogWriter(out io.Writer) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetLogWriter", out)
}

// SetLogWriter indicates an expected call of SetLogWriter.
func (mr *MockFrameworkMockRecorder) SetLogWriter(out any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogWriter", reflect.TypeOf((*MockFramework)(nil).SetLogWriter), out)
}

// SetLogger mocks base method.
func (m *MockFramework) SetLogger(logger *logrus.Logger) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetLogger", logger)
}

// SetLogger indicates an expected call of SetLogger.
func (mr *MockFrameworkMockRecorder) SetLogger(logger any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogger", reflect.TypeOf((*MockFramework)(nil).SetLogger), logger)
}

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

// SetupLogging indicates an expected call of SetupLogging.
func (mr *MockFrameworkMockRecorder) SetupLogging(debug any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetupLogging", reflect.TypeOf((*MockFramework)(nil).SetupLogging), debug)
}

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

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

// SignerToken mocks base method.
func (m *MockFramework) SignerToken() (string, time.Time, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SignerToken")
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(time.Time)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

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

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

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

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

// TLSConfig mocks base method.
func (m *MockFramework) 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 *MockFrameworkMockRecorder) TLSConfig() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TLSConfig", reflect.TypeOf((*MockFramework)(nil).TLSConfig))
}

// TrySrvLookup mocks base method.
func (m *MockFramework) TrySrvLookup(names []string, defaultSrv srvcache.Server) (srvcache.Server, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TrySrvLookup", names, defaultSrv)
	ret0, _ := ret[0].(srvcache.Server)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// TrySrvLookup indicates an expected call of TrySrvLookup.
func (mr *MockFrameworkMockRecorder) TrySrvLookup(names, defaultSrv any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TrySrvLookup", reflect.TypeOf((*MockFramework)(nil).TrySrvLookup), names, defaultSrv)
}

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

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

// UniqueIDFromUnverifiedToken mocks base method.
func (m *MockFramework) UniqueIDFromUnverifiedToken() (string, string, time.Time, string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UniqueIDFromUnverifiedToken")
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(string)
	ret2, _ := ret[2].(time.Time)
	ret3, _ := ret[3].(string)
	ret4, _ := ret[4].(error)
	return ret0, ret1, ret2, ret3, ret4
}

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

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

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