// Code generated by MockGen. DO NOT EDIT.
// Source: event_handler_context.go
//
// Generated by this command:
//
//	mockgen -typed -source event_handler_context.go -destination event_handler_context_mock_for_test.go -package flow
//

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

import (
	http "net/http"
	url "net/url"
	reflect "reflect"
	time "time"

	starlark "go.starlark.net/starlark"
	gomock "go.uber.org/mock/gomock"
)

// MockEventHandlerContext is a mock of EventHandlerContext interface.
type MockEventHandlerContext struct {
	ctrl     *gomock.Controller
	recorder *MockEventHandlerContextMockRecorder
	isgomock struct{}
}

// MockEventHandlerContextMockRecorder is the mock recorder for MockEventHandlerContext.
type MockEventHandlerContextMockRecorder struct {
	mock *MockEventHandlerContext
}

// NewMockEventHandlerContext creates a new mock instance.
func NewMockEventHandlerContext(ctrl *gomock.Controller) *MockEventHandlerContext {
	mock := &MockEventHandlerContext{ctrl: ctrl}
	mock.recorder = &MockEventHandlerContextMockRecorder{mock}
	return mock
}

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

// HTTPDo mocks base method.
func (m *MockEventHandlerContext) HTTPDo(reqURL, method string, query url.Values, header http.Header, body []byte) (*HTTPResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HTTPDo", reqURL, method, query, header, body)
	ret0, _ := ret[0].(*HTTPResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HTTPDo indicates an expected call of HTTPDo.
func (mr *MockEventHandlerContextMockRecorder) HTTPDo(reqURL, method, query, header, body any) *MockEventHandlerContextHTTPDoCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HTTPDo", reflect.TypeOf((*MockEventHandlerContext)(nil).HTTPDo), reqURL, method, query, header, body)
	return &MockEventHandlerContextHTTPDoCall{Call: call}
}

// MockEventHandlerContextHTTPDoCall wrap *gomock.Call
type MockEventHandlerContextHTTPDoCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockEventHandlerContextHTTPDoCall) Return(arg0 *HTTPResponse, arg1 error) *MockEventHandlerContextHTTPDoCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockEventHandlerContextHTTPDoCall) Do(f func(string, string, url.Values, http.Header, []byte) (*HTTPResponse, error)) *MockEventHandlerContextHTTPDoCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockEventHandlerContextHTTPDoCall) DoAndReturn(f func(string, string, url.Values, http.Header, []byte) (*HTTPResponse, error)) *MockEventHandlerContextHTTPDoCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Select mocks base method.
func (m *MockEventHandlerContext) Select(cases *starlark.Dict, defaultCase starlark.Value, timeout time.Duration, timeoutValue starlark.Value) (starlark.Value, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Select", cases, defaultCase, timeout, timeoutValue)
	ret0, _ := ret[0].(starlark.Value)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Select indicates an expected call of Select.
func (mr *MockEventHandlerContextMockRecorder) Select(cases, defaultCase, timeout, timeoutValue any) *MockEventHandlerContextSelectCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Select", reflect.TypeOf((*MockEventHandlerContext)(nil).Select), cases, defaultCase, timeout, timeoutValue)
	return &MockEventHandlerContextSelectCall{Call: call}
}

// MockEventHandlerContextSelectCall wrap *gomock.Call
type MockEventHandlerContextSelectCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockEventHandlerContextSelectCall) Return(arg0 starlark.Value, arg1 error) *MockEventHandlerContextSelectCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockEventHandlerContextSelectCall) Do(f func(*starlark.Dict, starlark.Value, time.Duration, starlark.Value) (starlark.Value, error)) *MockEventHandlerContextSelectCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockEventHandlerContextSelectCall) DoAndReturn(f func(*starlark.Dict, starlark.Value, time.Duration, starlark.Value) (starlark.Value, error)) *MockEventHandlerContextSelectCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Signal mocks base method.
func (m *MockEventHandlerContext) Signal(workflowID, signalName, payloadJSON, runID string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Signal", workflowID, signalName, payloadJSON, runID)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Signal indicates an expected call of Signal.
func (mr *MockEventHandlerContextMockRecorder) Signal(workflowID, signalName, payloadJSON, runID any) *MockEventHandlerContextSignalCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Signal", reflect.TypeOf((*MockEventHandlerContext)(nil).Signal), workflowID, signalName, payloadJSON, runID)
	return &MockEventHandlerContextSignalCall{Call: call}
}

// MockEventHandlerContextSignalCall wrap *gomock.Call
type MockEventHandlerContextSignalCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockEventHandlerContextSignalCall) Return(arg0 bool, arg1 error) *MockEventHandlerContextSignalCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockEventHandlerContextSignalCall) Do(f func(string, string, string, string) (bool, error)) *MockEventHandlerContextSignalCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockEventHandlerContextSignalCall) DoAndReturn(f func(string, string, string, string) (bool, error)) *MockEventHandlerContextSignalCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SignalChannel mocks base method.
func (m *MockEventHandlerContext) SignalChannel(signalName string) (ReceiveChannel, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SignalChannel", signalName)
	ret0, _ := ret[0].(ReceiveChannel)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SignalChannel indicates an expected call of SignalChannel.
func (mr *MockEventHandlerContextMockRecorder) SignalChannel(signalName any) *MockEventHandlerContextSignalChannelCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignalChannel", reflect.TypeOf((*MockEventHandlerContext)(nil).SignalChannel), signalName)
	return &MockEventHandlerContextSignalChannelCall{Call: call}
}

// MockEventHandlerContextSignalChannelCall wrap *gomock.Call
type MockEventHandlerContextSignalChannelCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockEventHandlerContextSignalChannelCall) Return(arg0 ReceiveChannel, arg1 error) *MockEventHandlerContextSignalChannelCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockEventHandlerContextSignalChannelCall) Do(f func(string) (ReceiveChannel, error)) *MockEventHandlerContextSignalChannelCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockEventHandlerContextSignalChannelCall) DoAndReturn(f func(string) (ReceiveChannel, error)) *MockEventHandlerContextSignalChannelCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// Sleep indicates an expected call of Sleep.
func (mr *MockEventHandlerContextMockRecorder) Sleep(duration any) *MockEventHandlerContextSleepCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Sleep", reflect.TypeOf((*MockEventHandlerContext)(nil).Sleep), duration)
	return &MockEventHandlerContextSleepCall{Call: call}
}

// MockEventHandlerContextSleepCall wrap *gomock.Call
type MockEventHandlerContextSleepCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockEventHandlerContextSleepCall) Return(arg0 error) *MockEventHandlerContextSleepCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockEventHandlerContextSleepCall) Do(f func(time.Duration) error) *MockEventHandlerContextSleepCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockEventHandlerContextSleepCall) DoAndReturn(f func(time.Duration) error) *MockEventHandlerContextSleepCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Timer mocks base method.
func (m *MockEventHandlerContext) Timer(duration time.Duration) Future {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Timer", duration)
	ret0, _ := ret[0].(Future)
	return ret0
}

// Timer indicates an expected call of Timer.
func (mr *MockEventHandlerContextMockRecorder) Timer(duration any) *MockEventHandlerContextTimerCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Timer", reflect.TypeOf((*MockEventHandlerContext)(nil).Timer), duration)
	return &MockEventHandlerContextTimerCall{Call: call}
}

// MockEventHandlerContextTimerCall wrap *gomock.Call
type MockEventHandlerContextTimerCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockEventHandlerContextTimerCall) Return(arg0 Future) *MockEventHandlerContextTimerCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockEventHandlerContextTimerCall) Do(f func(time.Duration) Future) *MockEventHandlerContextTimerCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockEventHandlerContextTimerCall) DoAndReturn(f func(time.Duration) Future) *MockEventHandlerContextTimerCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}
