// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/stacklok/toolhive/pkg/vmcp/session/types (interfaces: MultiSession)
//
// Generated by this command:
//
//	mockgen -destination=mocks/mock_session.go -package=mocks github.com/stacklok/toolhive/pkg/vmcp/session/types MultiSession
//

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

import (
	context "context"
	reflect "reflect"
	time "time"

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

// MockMultiSession is a mock of MultiSession interface.
type MockMultiSession struct {
	ctrl     *gomock.Controller
	recorder *MockMultiSessionMockRecorder
	isgomock struct{}
}

// MockMultiSessionMockRecorder is the mock recorder for MockMultiSession.
type MockMultiSessionMockRecorder struct {
	mock *MockMultiSession
}

// NewMockMultiSession creates a new mock instance.
func NewMockMultiSession(ctrl *gomock.Controller) *MockMultiSession {
	mock := &MockMultiSession{ctrl: ctrl}
	mock.recorder = &MockMultiSessionMockRecorder{mock}
	return mock
}

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

// AllTools mocks base method.
func (m *MockMultiSession) AllTools() []vmcp.Tool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AllTools")
	ret0, _ := ret[0].([]vmcp.Tool)
	return ret0
}

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

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

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

// CallTool mocks base method.
func (m *MockMultiSession) CallTool(ctx context.Context, caller *auth.Identity, toolName string, arguments, meta map[string]any) (*vmcp.ToolCallResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CallTool", ctx, caller, toolName, arguments, meta)
	ret0, _ := ret[0].(*vmcp.ToolCallResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CallTool indicates an expected call of CallTool.
func (mr *MockMultiSessionMockRecorder) CallTool(ctx, caller, toolName, arguments, meta any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CallTool", reflect.TypeOf((*MockMultiSession)(nil).CallTool), ctx, caller, toolName, arguments, meta)
}

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

// CreatedAt mocks base method.
func (m *MockMultiSession) CreatedAt() time.Time {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatedAt")
	ret0, _ := ret[0].(time.Time)
	return ret0
}

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

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

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

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

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

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

// GetMetadataValue indicates an expected call of GetMetadataValue.
func (mr *MockMultiSessionMockRecorder) GetMetadataValue(key any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMetadataValue", reflect.TypeOf((*MockMultiSession)(nil).GetMetadataValue), key)
}

// GetPrompt mocks base method.
func (m *MockMultiSession) GetPrompt(ctx context.Context, caller *auth.Identity, name string, arguments map[string]any) (*vmcp.PromptGetResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPrompt", ctx, caller, name, arguments)
	ret0, _ := ret[0].(*vmcp.PromptGetResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPrompt indicates an expected call of GetPrompt.
func (mr *MockMultiSessionMockRecorder) GetPrompt(ctx, caller, name, arguments any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPrompt", reflect.TypeOf((*MockMultiSession)(nil).GetPrompt), ctx, caller, name, arguments)
}

// GetRoutingTable mocks base method.
func (m *MockMultiSession) GetRoutingTable() *vmcp.RoutingTable {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRoutingTable")
	ret0, _ := ret[0].(*vmcp.RoutingTable)
	return ret0
}

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

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

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

// Prompts mocks base method.
func (m *MockMultiSession) Prompts() []vmcp.Prompt {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Prompts")
	ret0, _ := ret[0].([]vmcp.Prompt)
	return ret0
}

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

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

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

// Resources mocks base method.
func (m *MockMultiSession) Resources() []vmcp.Resource {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Resources")
	ret0, _ := ret[0].([]vmcp.Resource)
	return ret0
}

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

// SetData mocks base method.
func (m *MockMultiSession) SetData(data any) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetData", data)
}

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

// SetMetadata mocks base method.
func (m *MockMultiSession) SetMetadata(key, value string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetMetadata", key, value)
}

// SetMetadata indicates an expected call of SetMetadata.
func (mr *MockMultiSessionMockRecorder) SetMetadata(key, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMetadata", reflect.TypeOf((*MockMultiSession)(nil).SetMetadata), key, value)
}

// Tools mocks base method.
func (m *MockMultiSession) Tools() []vmcp.Tool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Tools")
	ret0, _ := ret[0].([]vmcp.Tool)
	return ret0
}

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

// Type mocks base method.
func (m *MockMultiSession) Type() session.SessionType {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Type")
	ret0, _ := ret[0].(session.SessionType)
	return ret0
}

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

// UpdatedAt mocks base method.
func (m *MockMultiSession) UpdatedAt() time.Time {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdatedAt")
	ret0, _ := ret[0].(time.Time)
	return ret0
}

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