// Code generated by MockGen. DO NOT EDIT.
// Source: router.go
//
// Generated by this command:
//
//	mockgen -destination=mocks/mock_router.go -package=mocks -source=router.go Router RoutingStrategy SessionAffinityProvider
//

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

import (
	context "context"
	reflect "reflect"

	vmcp "github.com/stacklok/toolhive/pkg/vmcp"
	gomock "go.uber.org/mock/gomock"
)

// MockRouter is a mock of Router interface.
type MockRouter struct {
	ctrl     *gomock.Controller
	recorder *MockRouterMockRecorder
	isgomock struct{}
}

// MockRouterMockRecorder is the mock recorder for MockRouter.
type MockRouterMockRecorder struct {
	mock *MockRouter
}

// NewMockRouter creates a new mock instance.
func NewMockRouter(ctrl *gomock.Controller) *MockRouter {
	mock := &MockRouter{ctrl: ctrl}
	mock.recorder = &MockRouterMockRecorder{mock}
	return mock
}

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

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

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

// RoutePrompt mocks base method.
func (m *MockRouter) RoutePrompt(ctx context.Context, name string) (*vmcp.BackendTarget, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RoutePrompt", ctx, name)
	ret0, _ := ret[0].(*vmcp.BackendTarget)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RouteResource mocks base method.
func (m *MockRouter) RouteResource(ctx context.Context, uri string) (*vmcp.BackendTarget, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RouteResource", ctx, uri)
	ret0, _ := ret[0].(*vmcp.BackendTarget)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RouteTool mocks base method.
func (m *MockRouter) RouteTool(ctx context.Context, toolName string) (*vmcp.BackendTarget, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RouteTool", ctx, toolName)
	ret0, _ := ret[0].(*vmcp.BackendTarget)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockRoutingStrategy is a mock of RoutingStrategy interface.
type MockRoutingStrategy struct {
	ctrl     *gomock.Controller
	recorder *MockRoutingStrategyMockRecorder
	isgomock struct{}
}

// MockRoutingStrategyMockRecorder is the mock recorder for MockRoutingStrategy.
type MockRoutingStrategyMockRecorder struct {
	mock *MockRoutingStrategy
}

// NewMockRoutingStrategy creates a new mock instance.
func NewMockRoutingStrategy(ctrl *gomock.Controller) *MockRoutingStrategy {
	mock := &MockRoutingStrategy{ctrl: ctrl}
	mock.recorder = &MockRoutingStrategyMockRecorder{mock}
	return mock
}

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

// SelectBackend mocks base method.
func (m *MockRoutingStrategy) SelectBackend(ctx context.Context, candidates []*vmcp.BackendTarget) (*vmcp.BackendTarget, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectBackend", ctx, candidates)
	ret0, _ := ret[0].(*vmcp.BackendTarget)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockSessionAffinityProvider is a mock of SessionAffinityProvider interface.
type MockSessionAffinityProvider struct {
	ctrl     *gomock.Controller
	recorder *MockSessionAffinityProviderMockRecorder
	isgomock struct{}
}

// MockSessionAffinityProviderMockRecorder is the mock recorder for MockSessionAffinityProvider.
type MockSessionAffinityProviderMockRecorder struct {
	mock *MockSessionAffinityProvider
}

// NewMockSessionAffinityProvider creates a new mock instance.
func NewMockSessionAffinityProvider(ctrl *gomock.Controller) *MockSessionAffinityProvider {
	mock := &MockSessionAffinityProvider{ctrl: ctrl}
	mock.recorder = &MockSessionAffinityProviderMockRecorder{mock}
	return mock
}

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

// GetBackendForSession mocks base method.
func (m *MockSessionAffinityProvider) GetBackendForSession(ctx context.Context, sessionID string) (*vmcp.BackendTarget, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBackendForSession", ctx, sessionID)
	ret0, _ := ret[0].(*vmcp.BackendTarget)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// SetBackendForSession mocks base method.
func (m *MockSessionAffinityProvider) SetBackendForSession(ctx context.Context, sessionID string, target *vmcp.BackendTarget) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetBackendForSession", ctx, sessionID, target)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetBackendForSession indicates an expected call of SetBackendForSession.
func (mr *MockSessionAffinityProviderMockRecorder) SetBackendForSession(ctx, sessionID, target any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetBackendForSession", reflect.TypeOf((*MockSessionAffinityProvider)(nil).SetBackendForSession), ctx, sessionID, target)
}
