// Code generated by MockGen. DO NOT EDIT.
// Source: transport.go
//
// Generated by this command:
//
//	mockgen -package mocks -destination=mocks/mock_transport.go -source=transport.go MiddlewareRunner,RunnerConfig
//

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

import (
	context "context"
	http "net/http"
	reflect "reflect"

	upstreamtoken "github.com/stacklok/toolhive/pkg/auth/upstreamtoken"
	keys "github.com/stacklok/toolhive/pkg/authserver/server/keys"
	types "github.com/stacklok/toolhive/pkg/transport/types"
	gomock "go.uber.org/mock/gomock"
	jsonrpc2 "golang.org/x/exp/jsonrpc2"
	oauth2 "golang.org/x/oauth2"
)

// MockMiddleware is a mock of Middleware interface.
type MockMiddleware struct {
	ctrl     *gomock.Controller
	recorder *MockMiddlewareMockRecorder
	isgomock struct{}
}

// MockMiddlewareMockRecorder is the mock recorder for MockMiddleware.
type MockMiddlewareMockRecorder struct {
	mock *MockMiddleware
}

// NewMockMiddleware creates a new mock instance.
func NewMockMiddleware(ctrl *gomock.Controller) *MockMiddleware {
	mock := &MockMiddleware{ctrl: ctrl}
	mock.recorder = &MockMiddlewareMockRecorder{mock}
	return mock
}

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

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

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

// Handler mocks base method.
func (m *MockMiddleware) Handler() types.MiddlewareFunction {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Handler")
	ret0, _ := ret[0].(types.MiddlewareFunction)
	return ret0
}

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

// MockMiddlewareRunner is a mock of MiddlewareRunner interface.
type MockMiddlewareRunner struct {
	ctrl     *gomock.Controller
	recorder *MockMiddlewareRunnerMockRecorder
	isgomock struct{}
}

// MockMiddlewareRunnerMockRecorder is the mock recorder for MockMiddlewareRunner.
type MockMiddlewareRunnerMockRecorder struct {
	mock *MockMiddlewareRunner
}

// NewMockMiddlewareRunner creates a new mock instance.
func NewMockMiddlewareRunner(ctrl *gomock.Controller) *MockMiddlewareRunner {
	mock := &MockMiddlewareRunner{ctrl: ctrl}
	mock.recorder = &MockMiddlewareRunnerMockRecorder{mock}
	return mock
}

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

// AddMiddleware mocks base method.
func (m *MockMiddlewareRunner) AddMiddleware(name string, middleware types.Middleware) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddMiddleware", name, middleware)
}

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

// GetConfig mocks base method.
func (m *MockMiddlewareRunner) GetConfig() types.RunnerConfig {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetConfig")
	ret0, _ := ret[0].(types.RunnerConfig)
	return ret0
}

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

// GetKeyProvider mocks base method.
func (m *MockMiddlewareRunner) GetKeyProvider() keys.PublicKeyProvider {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetKeyProvider")
	ret0, _ := ret[0].(keys.PublicKeyProvider)
	return ret0
}

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

// GetUpstreamTokenReader mocks base method.
func (m *MockMiddlewareRunner) GetUpstreamTokenReader() upstreamtoken.TokenReader {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUpstreamTokenReader")
	ret0, _ := ret[0].(upstreamtoken.TokenReader)
	return ret0
}

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

// SetAuthInfoHandler mocks base method.
func (m *MockMiddlewareRunner) SetAuthInfoHandler(handler http.Handler) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetAuthInfoHandler", handler)
}

// SetAuthInfoHandler indicates an expected call of SetAuthInfoHandler.
func (mr *MockMiddlewareRunnerMockRecorder) SetAuthInfoHandler(handler any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAuthInfoHandler", reflect.TypeOf((*MockMiddlewareRunner)(nil).SetAuthInfoHandler), handler)
}

// SetPrometheusHandler mocks base method.
func (m *MockMiddlewareRunner) SetPrometheusHandler(handler http.Handler) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetPrometheusHandler", handler)
}

// SetPrometheusHandler indicates an expected call of SetPrometheusHandler.
func (mr *MockMiddlewareRunnerMockRecorder) SetPrometheusHandler(handler any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPrometheusHandler", reflect.TypeOf((*MockMiddlewareRunner)(nil).SetPrometheusHandler), handler)
}

// MockRunnerConfig is a mock of RunnerConfig interface.
type MockRunnerConfig struct {
	ctrl     *gomock.Controller
	recorder *MockRunnerConfigMockRecorder
	isgomock struct{}
}

// MockRunnerConfigMockRecorder is the mock recorder for MockRunnerConfig.
type MockRunnerConfigMockRecorder struct {
	mock *MockRunnerConfig
}

// NewMockRunnerConfig creates a new mock instance.
func NewMockRunnerConfig(ctrl *gomock.Controller) *MockRunnerConfig {
	mock := &MockRunnerConfig{ctrl: ctrl}
	mock.recorder = &MockRunnerConfigMockRecorder{mock}
	return mock
}

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

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

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

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

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

// MockTransport is a mock of Transport interface.
type MockTransport struct {
	ctrl     *gomock.Controller
	recorder *MockTransportMockRecorder
	isgomock struct{}
}

// MockTransportMockRecorder is the mock recorder for MockTransport.
type MockTransportMockRecorder struct {
	mock *MockTransport
}

// NewMockTransport creates a new mock instance.
func NewMockTransport(ctrl *gomock.Controller) *MockTransport {
	mock := &MockTransport{ctrl: ctrl}
	mock.recorder = &MockTransportMockRecorder{mock}
	return mock
}

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

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

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

// Mode mocks base method.
func (m *MockTransport) Mode() types.TransportType {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Mode")
	ret0, _ := ret[0].(types.TransportType)
	return ret0
}

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

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

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

// SetOnHealthCheckFailed mocks base method.
func (m *MockTransport) SetOnHealthCheckFailed(callback types.HealthCheckFailedCallback) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetOnHealthCheckFailed", callback)
}

// SetOnHealthCheckFailed indicates an expected call of SetOnHealthCheckFailed.
func (mr *MockTransportMockRecorder) SetOnHealthCheckFailed(callback any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetOnHealthCheckFailed", reflect.TypeOf((*MockTransport)(nil).SetOnHealthCheckFailed), callback)
}

// SetOnUnauthorizedResponse mocks base method.
func (m *MockTransport) SetOnUnauthorizedResponse(callback types.UnauthorizedResponseCallback) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetOnUnauthorizedResponse", callback)
}

// SetOnUnauthorizedResponse indicates an expected call of SetOnUnauthorizedResponse.
func (mr *MockTransportMockRecorder) SetOnUnauthorizedResponse(callback any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetOnUnauthorizedResponse", reflect.TypeOf((*MockTransport)(nil).SetOnUnauthorizedResponse), callback)
}

// SetRemoteURL mocks base method.
func (m *MockTransport) SetRemoteURL(remoteURL string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetRemoteURL", remoteURL)
}

// SetRemoteURL indicates an expected call of SetRemoteURL.
func (mr *MockTransportMockRecorder) SetRemoteURL(remoteURL any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRemoteURL", reflect.TypeOf((*MockTransport)(nil).SetRemoteURL), remoteURL)
}

// SetTokenSource mocks base method.
func (m *MockTransport) SetTokenSource(tokenSource oauth2.TokenSource) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTokenSource", tokenSource)
}

// SetTokenSource indicates an expected call of SetTokenSource.
func (mr *MockTransportMockRecorder) SetTokenSource(tokenSource any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTokenSource", reflect.TypeOf((*MockTransport)(nil).SetTokenSource), tokenSource)
}

// Start mocks base method.
func (m *MockTransport) Start(ctx context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Start", ctx)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// Stop mocks base method.
func (m *MockTransport) Stop(ctx context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Stop", ctx)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// MockProxy is a mock of Proxy interface.
type MockProxy struct {
	ctrl     *gomock.Controller
	recorder *MockProxyMockRecorder
	isgomock struct{}
}

// MockProxyMockRecorder is the mock recorder for MockProxy.
type MockProxyMockRecorder struct {
	mock *MockProxy
}

// NewMockProxy creates a new mock instance.
func NewMockProxy(ctrl *gomock.Controller) *MockProxy {
	mock := &MockProxy{ctrl: ctrl}
	mock.recorder = &MockProxyMockRecorder{mock}
	return mock
}

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

// ForwardResponseToClients mocks base method.
func (m *MockProxy) ForwardResponseToClients(ctx context.Context, msg jsonrpc2.Message) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ForwardResponseToClients", ctx, msg)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// GetMessageChannel mocks base method.
func (m *MockProxy) GetMessageChannel() chan jsonrpc2.Message {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMessageChannel")
	ret0, _ := ret[0].(chan jsonrpc2.Message)
	return ret0
}

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

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

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

// SendMessageToDestination mocks base method.
func (m *MockProxy) SendMessageToDestination(msg jsonrpc2.Message) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendMessageToDestination", msg)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// Start mocks base method.
func (m *MockProxy) Start(ctx context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Start", ctx)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// Stop mocks base method.
func (m *MockProxy) Stop(ctx context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Stop", ctx)
	ret0, _ := ret[0].(error)
	return ret0
}

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