// Code generated by MockGen. DO NOT EDIT.
// Source: infra.go
//
// Generated by this command:
//
//	mockgen -source=infra.go -destination=../mocks/infra.go -package=mocks
//

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

import (
	context "context"
	url "net/url"
	reflect "reflect"

	interfaces "github.com/kweaver-ai/adp/context-loader/agent-retrieval/server/interfaces"
	gomock "go.uber.org/mock/gomock"
)

// MockLogger is a mock of Logger interface.
type MockLogger struct {
	ctrl     *gomock.Controller
	recorder *MockLoggerMockRecorder
	isgomock struct{}
}

// MockLoggerMockRecorder is the mock recorder for MockLogger.
type MockLoggerMockRecorder struct {
	mock *MockLogger
}

// NewMockLogger creates a new mock instance.
func NewMockLogger(ctrl *gomock.Controller) *MockLogger {
	mock := &MockLogger{ctrl: ctrl}
	mock.recorder = &MockLoggerMockRecorder{mock}
	return mock
}

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

// Debug mocks base method.
func (m *MockLogger) Debug(v ...any) {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range v {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Debug", varargs...)
}

// Debug indicates an expected call of Debug.
func (mr *MockLoggerMockRecorder) Debug(v ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Debug", reflect.TypeOf((*MockLogger)(nil).Debug), v...)
}

// Debugf mocks base method.
func (m *MockLogger) Debugf(format string, v ...any) {
	m.ctrl.T.Helper()
	varargs := []any{format}
	for _, a := range v {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Debugf", varargs...)
}

// Debugf indicates an expected call of Debugf.
func (mr *MockLoggerMockRecorder) Debugf(format any, v ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{format}, v...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Debugf", reflect.TypeOf((*MockLogger)(nil).Debugf), varargs...)
}

// Error mocks base method.
func (m *MockLogger) Error(v ...any) {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range v {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Error", varargs...)
}

// Error indicates an expected call of Error.
func (mr *MockLoggerMockRecorder) Error(v ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Error", reflect.TypeOf((*MockLogger)(nil).Error), v...)
}

// Errorf mocks base method.
func (m *MockLogger) Errorf(format string, v ...any) {
	m.ctrl.T.Helper()
	varargs := []any{format}
	for _, a := range v {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Errorf", varargs...)
}

// Errorf indicates an expected call of Errorf.
func (mr *MockLoggerMockRecorder) Errorf(format any, v ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{format}, v...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Errorf", reflect.TypeOf((*MockLogger)(nil).Errorf), varargs...)
}

// Info mocks base method.
func (m *MockLogger) Info(v ...any) {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range v {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Info", varargs...)
}

// Info indicates an expected call of Info.
func (mr *MockLoggerMockRecorder) Info(v ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Info", reflect.TypeOf((*MockLogger)(nil).Info), v...)
}

// Infof mocks base method.
func (m *MockLogger) Infof(format string, v ...any) {
	m.ctrl.T.Helper()
	varargs := []any{format}
	for _, a := range v {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Infof", varargs...)
}

// Infof indicates an expected call of Infof.
func (mr *MockLoggerMockRecorder) Infof(format any, v ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{format}, v...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Infof", reflect.TypeOf((*MockLogger)(nil).Infof), varargs...)
}

// Warn mocks base method.
func (m *MockLogger) Warn(v ...any) {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range v {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Warn", varargs...)
}

// Warn indicates an expected call of Warn.
func (mr *MockLoggerMockRecorder) Warn(v ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Warn", reflect.TypeOf((*MockLogger)(nil).Warn), v...)
}

// Warnf mocks base method.
func (m *MockLogger) Warnf(format string, v ...any) {
	m.ctrl.T.Helper()
	varargs := []any{format}
	for _, a := range v {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Warnf", varargs...)
}

// Warnf indicates an expected call of Warnf.
func (mr *MockLoggerMockRecorder) Warnf(format any, v ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{format}, v...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Warnf", reflect.TypeOf((*MockLogger)(nil).Warnf), varargs...)
}

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

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

// MockHTTPClient is a mock of HTTPClient interface.
type MockHTTPClient struct {
	ctrl     *gomock.Controller
	recorder *MockHTTPClientMockRecorder
	isgomock struct{}
}

// MockHTTPClientMockRecorder is the mock recorder for MockHTTPClient.
type MockHTTPClientMockRecorder struct {
	mock *MockHTTPClient
}

// NewMockHTTPClient creates a new mock instance.
func NewMockHTTPClient(ctrl *gomock.Controller) *MockHTTPClient {
	mock := &MockHTTPClient{ctrl: ctrl}
	mock.recorder = &MockHTTPClientMockRecorder{mock}
	return mock
}

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

// Delete mocks base method.
func (m *MockHTTPClient) Delete(ctx context.Context, arg1 string, headers map[string]string) (int, any, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", ctx, arg1, headers)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(any)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Delete indicates an expected call of Delete.
func (mr *MockHTTPClientMockRecorder) Delete(ctx, arg1, headers any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockHTTPClient)(nil).Delete), ctx, arg1, headers)
}

// DeleteNoUnmarshal mocks base method.
func (m *MockHTTPClient) DeleteNoUnmarshal(ctx context.Context, arg1 string, headers map[string]string) (int, []byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNoUnmarshal", ctx, arg1, headers)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// DeleteNoUnmarshal indicates an expected call of DeleteNoUnmarshal.
func (mr *MockHTTPClientMockRecorder) DeleteNoUnmarshal(ctx, arg1, headers any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNoUnmarshal", reflect.TypeOf((*MockHTTPClient)(nil).DeleteNoUnmarshal), ctx, arg1, headers)
}

// Get mocks base method.
func (m *MockHTTPClient) Get(ctx context.Context, arg1 string, queryValues url.Values, headers map[string]string) (int, any, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", ctx, arg1, queryValues, headers)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(any)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Get indicates an expected call of Get.
func (mr *MockHTTPClientMockRecorder) Get(ctx, arg1, queryValues, headers any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockHTTPClient)(nil).Get), ctx, arg1, queryValues, headers)
}

// GetNoUnmarshal mocks base method.
func (m *MockHTTPClient) GetNoUnmarshal(ctx context.Context, arg1 string, queryValues url.Values, headers map[string]string) (int, []byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNoUnmarshal", ctx, arg1, queryValues, headers)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetNoUnmarshal indicates an expected call of GetNoUnmarshal.
func (mr *MockHTTPClientMockRecorder) GetNoUnmarshal(ctx, arg1, queryValues, headers any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNoUnmarshal", reflect.TypeOf((*MockHTTPClient)(nil).GetNoUnmarshal), ctx, arg1, queryValues, headers)
}

// Patch mocks base method.
func (m *MockHTTPClient) Patch(ctx context.Context, arg1 string, headers map[string]string, reqParam any) (int, any, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Patch", ctx, arg1, headers, reqParam)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(any)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Patch indicates an expected call of Patch.
func (mr *MockHTTPClientMockRecorder) Patch(ctx, arg1, headers, reqParam any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Patch", reflect.TypeOf((*MockHTTPClient)(nil).Patch), ctx, arg1, headers, reqParam)
}

// PatchNoUnmarshal mocks base method.
func (m *MockHTTPClient) PatchNoUnmarshal(ctx context.Context, arg1 string, headers map[string]string, reqParam any) (int, []byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PatchNoUnmarshal", ctx, arg1, headers, reqParam)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// PatchNoUnmarshal indicates an expected call of PatchNoUnmarshal.
func (mr *MockHTTPClientMockRecorder) PatchNoUnmarshal(ctx, arg1, headers, reqParam any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchNoUnmarshal", reflect.TypeOf((*MockHTTPClient)(nil).PatchNoUnmarshal), ctx, arg1, headers, reqParam)
}

// Post mocks base method.
func (m *MockHTTPClient) Post(ctx context.Context, arg1 string, headers map[string]string, reqParam any) (int, any, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Post", ctx, arg1, headers, reqParam)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(any)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Post indicates an expected call of Post.
func (mr *MockHTTPClientMockRecorder) Post(ctx, arg1, headers, reqParam any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Post", reflect.TypeOf((*MockHTTPClient)(nil).Post), ctx, arg1, headers, reqParam)
}

// PostNoUnmarshal mocks base method.
func (m *MockHTTPClient) PostNoUnmarshal(ctx context.Context, arg1 string, headers map[string]string, reqParam any) (int, []byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PostNoUnmarshal", ctx, arg1, headers, reqParam)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// PostNoUnmarshal indicates an expected call of PostNoUnmarshal.
func (mr *MockHTTPClientMockRecorder) PostNoUnmarshal(ctx, arg1, headers, reqParam any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostNoUnmarshal", reflect.TypeOf((*MockHTTPClient)(nil).PostNoUnmarshal), ctx, arg1, headers, reqParam)
}

// Put mocks base method.
func (m *MockHTTPClient) Put(ctx context.Context, arg1 string, headers map[string]string, reqParam any) (int, any, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Put", ctx, arg1, headers, reqParam)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(any)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Put indicates an expected call of Put.
func (mr *MockHTTPClientMockRecorder) Put(ctx, arg1, headers, reqParam any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Put", reflect.TypeOf((*MockHTTPClient)(nil).Put), ctx, arg1, headers, reqParam)
}

// PutNoUnmarshal mocks base method.
func (m *MockHTTPClient) PutNoUnmarshal(ctx context.Context, arg1 string, headers map[string]string, reqParam any) (int, []byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutNoUnmarshal", ctx, arg1, headers, reqParam)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// PutNoUnmarshal indicates an expected call of PutNoUnmarshal.
func (mr *MockHTTPClientMockRecorder) PutNoUnmarshal(ctx, arg1, headers, reqParam any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutNoUnmarshal", reflect.TypeOf((*MockHTTPClient)(nil).PutNoUnmarshal), ctx, arg1, headers, reqParam)
}
