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

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

import (
	context "context"
	io "io"
	reflect "reflect"

	interfaces "github.com/kweaver-ai/adp/execution-factory/operator-integration/server/interfaces"
	gomock "go.uber.org/mock/gomock"
)

// MockProxyHandler is a mock of ProxyHandler interface.
type MockProxyHandler struct {
	ctrl     *gomock.Controller
	recorder *MockProxyHandlerMockRecorder
	isgomock struct{}
}

// MockProxyHandlerMockRecorder is the mock recorder for MockProxyHandler.
type MockProxyHandlerMockRecorder struct {
	mock *MockProxyHandler
}

// NewMockProxyHandler creates a new mock instance.
func NewMockProxyHandler(ctrl *gomock.Controller) *MockProxyHandler {
	mock := &MockProxyHandler{ctrl: ctrl}
	mock.recorder = &MockProxyHandlerMockRecorder{mock}
	return mock
}

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

// HandlerRequest mocks base method.
func (m *MockProxyHandler) HandlerRequest(ctx context.Context, req *interfaces.HTTPRequest) (*interfaces.HTTPResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandlerRequest", ctx, req)
	ret0, _ := ret[0].(*interfaces.HTTPResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockIOutboxMessageEvent is a mock of IOutboxMessageEvent interface.
type MockIOutboxMessageEvent struct {
	ctrl     *gomock.Controller
	recorder *MockIOutboxMessageEventMockRecorder
	isgomock struct{}
}

// MockIOutboxMessageEventMockRecorder is the mock recorder for MockIOutboxMessageEvent.
type MockIOutboxMessageEventMockRecorder struct {
	mock *MockIOutboxMessageEvent
}

// NewMockIOutboxMessageEvent creates a new mock instance.
func NewMockIOutboxMessageEvent(ctrl *gomock.Controller) *MockIOutboxMessageEvent {
	mock := &MockIOutboxMessageEvent{ctrl: ctrl}
	mock.recorder = &MockIOutboxMessageEventMockRecorder{mock}
	return mock
}

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

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

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

// MockForwarder is a mock of Forwarder interface.
type MockForwarder struct {
	ctrl     *gomock.Controller
	recorder *MockForwarderMockRecorder
	isgomock struct{}
}

// MockForwarderMockRecorder is the mock recorder for MockForwarder.
type MockForwarderMockRecorder struct {
	mock *MockForwarder
}

// NewMockForwarder creates a new mock instance.
func NewMockForwarder(ctrl *gomock.Controller) *MockForwarder {
	mock := &MockForwarder{ctrl: ctrl}
	mock.recorder = &MockForwarderMockRecorder{mock}
	return mock
}

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

// Forward mocks base method.
func (m *MockForwarder) Forward(ctx context.Context, req *interfaces.HTTPRequest) (*interfaces.HTTPResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Forward", ctx, req)
	ret0, _ := ret[0].(*interfaces.HTTPResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ForwardStream mocks base method.
func (m *MockForwarder) ForwardStream(ctx context.Context, req *interfaces.HTTPRequest) (*interfaces.HTTPResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ForwardStream", ctx, req)
	ret0, _ := ret[0].(*interfaces.HTTPResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockStreamProcessor is a mock of StreamProcessor interface.
type MockStreamProcessor struct {
	ctrl     *gomock.Controller
	recorder *MockStreamProcessorMockRecorder
	isgomock struct{}
}

// MockStreamProcessorMockRecorder is the mock recorder for MockStreamProcessor.
type MockStreamProcessorMockRecorder struct {
	mock *MockStreamProcessor
}

// NewMockStreamProcessor creates a new mock instance.
func NewMockStreamProcessor(ctrl *gomock.Controller) *MockStreamProcessor {
	mock := &MockStreamProcessor{ctrl: ctrl}
	mock.recorder = &MockStreamProcessorMockRecorder{mock}
	return mock
}

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

// ProcessHTTPStream mocks base method.
func (m *MockStreamProcessor) ProcessHTTPStream(ctx context.Context, reader io.Reader, writer io.Writer) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ProcessHTTPStream", ctx, reader, writer)
	ret0, _ := ret[0].(error)
	return ret0
}

// ProcessHTTPStream indicates an expected call of ProcessHTTPStream.
func (mr *MockStreamProcessorMockRecorder) ProcessHTTPStream(ctx, reader, writer any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProcessHTTPStream", reflect.TypeOf((*MockStreamProcessor)(nil).ProcessHTTPStream), ctx, reader, writer)
}

// ProcessSSE mocks base method.
func (m *MockStreamProcessor) ProcessSSE(ctx context.Context, reader io.Reader, writer io.Writer) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ProcessSSE", ctx, reader, writer)
	ret0, _ := ret[0].(error)
	return ret0
}

// ProcessSSE indicates an expected call of ProcessSSE.
func (mr *MockStreamProcessorMockRecorder) ProcessSSE(ctx, reader, writer any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProcessSSE", reflect.TypeOf((*MockStreamProcessor)(nil).ProcessSSE), ctx, reader, writer)
}
