// Code generated by MockGen. DO NOT EDIT.
// Source: sink.go

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

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

	event "github.com/authgear/authgear-server/pkg/api/event"
	rolesgroups "github.com/authgear/authgear-server/pkg/lib/rolesgroups"
	accesscontrol "github.com/authgear/authgear-server/pkg/util/accesscontrol"
	gomock "github.com/golang/mock/gomock"
)

// MockStandardAttributesServiceNoEvent is a mock of StandardAttributesServiceNoEvent interface.
type MockStandardAttributesServiceNoEvent struct {
	ctrl     *gomock.Controller
	recorder *MockStandardAttributesServiceNoEventMockRecorder
}

// MockStandardAttributesServiceNoEventMockRecorder is the mock recorder for MockStandardAttributesServiceNoEvent.
type MockStandardAttributesServiceNoEventMockRecorder struct {
	mock *MockStandardAttributesServiceNoEvent
}

// NewMockStandardAttributesServiceNoEvent creates a new mock instance.
func NewMockStandardAttributesServiceNoEvent(ctrl *gomock.Controller) *MockStandardAttributesServiceNoEvent {
	mock := &MockStandardAttributesServiceNoEvent{ctrl: ctrl}
	mock.recorder = &MockStandardAttributesServiceNoEventMockRecorder{mock}
	return mock
}

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

// UpdateStandardAttributes mocks base method.
func (m *MockStandardAttributesServiceNoEvent) UpdateStandardAttributes(ctx context.Context, role accesscontrol.Role, userID string, stdAttrs map[string]interface{}) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateStandardAttributes", ctx, role, userID, stdAttrs)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateStandardAttributes indicates an expected call of UpdateStandardAttributes.
func (mr *MockStandardAttributesServiceNoEventMockRecorder) UpdateStandardAttributes(ctx, role, userID, stdAttrs interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateStandardAttributes", reflect.TypeOf((*MockStandardAttributesServiceNoEvent)(nil).UpdateStandardAttributes), ctx, role, userID, stdAttrs)
}

// MockCustomAttributesServiceNoEvent is a mock of CustomAttributesServiceNoEvent interface.
type MockCustomAttributesServiceNoEvent struct {
	ctrl     *gomock.Controller
	recorder *MockCustomAttributesServiceNoEventMockRecorder
}

// MockCustomAttributesServiceNoEventMockRecorder is the mock recorder for MockCustomAttributesServiceNoEvent.
type MockCustomAttributesServiceNoEventMockRecorder struct {
	mock *MockCustomAttributesServiceNoEvent
}

// NewMockCustomAttributesServiceNoEvent creates a new mock instance.
func NewMockCustomAttributesServiceNoEvent(ctrl *gomock.Controller) *MockCustomAttributesServiceNoEvent {
	mock := &MockCustomAttributesServiceNoEvent{ctrl: ctrl}
	mock.recorder = &MockCustomAttributesServiceNoEventMockRecorder{mock}
	return mock
}

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

// UpdateAllCustomAttributes mocks base method.
func (m *MockCustomAttributesServiceNoEvent) UpdateAllCustomAttributes(ctx context.Context, role accesscontrol.Role, userID string, reprForm map[string]interface{}) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateAllCustomAttributes", ctx, role, userID, reprForm)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateAllCustomAttributes indicates an expected call of UpdateAllCustomAttributes.
func (mr *MockCustomAttributesServiceNoEventMockRecorder) UpdateAllCustomAttributes(ctx, role, userID, reprForm interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAllCustomAttributes", reflect.TypeOf((*MockCustomAttributesServiceNoEvent)(nil).UpdateAllCustomAttributes), ctx, role, userID, reprForm)
}

// MockRolesAndGroupsServiceNoEvent is a mock of RolesAndGroupsServiceNoEvent interface.
type MockRolesAndGroupsServiceNoEvent struct {
	ctrl     *gomock.Controller
	recorder *MockRolesAndGroupsServiceNoEventMockRecorder
}

// MockRolesAndGroupsServiceNoEventMockRecorder is the mock recorder for MockRolesAndGroupsServiceNoEvent.
type MockRolesAndGroupsServiceNoEventMockRecorder struct {
	mock *MockRolesAndGroupsServiceNoEvent
}

// NewMockRolesAndGroupsServiceNoEvent creates a new mock instance.
func NewMockRolesAndGroupsServiceNoEvent(ctrl *gomock.Controller) *MockRolesAndGroupsServiceNoEvent {
	mock := &MockRolesAndGroupsServiceNoEvent{ctrl: ctrl}
	mock.recorder = &MockRolesAndGroupsServiceNoEventMockRecorder{mock}
	return mock
}

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

// ResetUserGroup mocks base method.
func (m *MockRolesAndGroupsServiceNoEvent) ResetUserGroup(ctx context.Context, options *rolesgroups.ResetUserGroupOptions) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResetUserGroup", ctx, options)
	ret0, _ := ret[0].(error)
	return ret0
}

// ResetUserGroup indicates an expected call of ResetUserGroup.
func (mr *MockRolesAndGroupsServiceNoEventMockRecorder) ResetUserGroup(ctx, options interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetUserGroup", reflect.TypeOf((*MockRolesAndGroupsServiceNoEvent)(nil).ResetUserGroup), ctx, options)
}

// ResetUserRole mocks base method.
func (m *MockRolesAndGroupsServiceNoEvent) ResetUserRole(ctx context.Context, options *rolesgroups.ResetUserRoleOptions) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResetUserRole", ctx, options)
	ret0, _ := ret[0].(error)
	return ret0
}

// ResetUserRole indicates an expected call of ResetUserRole.
func (mr *MockRolesAndGroupsServiceNoEventMockRecorder) ResetUserRole(ctx, options interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetUserRole", reflect.TypeOf((*MockRolesAndGroupsServiceNoEvent)(nil).ResetUserRole), ctx, options)
}

// MockEventWebHook is a mock of EventWebHook interface.
type MockEventWebHook struct {
	ctrl     *gomock.Controller
	recorder *MockEventWebHookMockRecorder
}

// MockEventWebHookMockRecorder is the mock recorder for MockEventWebHook.
type MockEventWebHookMockRecorder struct {
	mock *MockEventWebHook
}

// NewMockEventWebHook creates a new mock instance.
func NewMockEventWebHook(ctrl *gomock.Controller) *MockEventWebHook {
	mock := &MockEventWebHook{ctrl: ctrl}
	mock.recorder = &MockEventWebHookMockRecorder{mock}
	return mock
}

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

// DeliverBlockingEvent mocks base method.
func (m *MockEventWebHook) DeliverBlockingEvent(ctx context.Context, u *url.URL, e *event.Event) (*event.HookResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeliverBlockingEvent", ctx, u, e)
	ret0, _ := ret[0].(*event.HookResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeliverBlockingEvent indicates an expected call of DeliverBlockingEvent.
func (mr *MockEventWebHookMockRecorder) DeliverBlockingEvent(ctx, u, e interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeliverBlockingEvent", reflect.TypeOf((*MockEventWebHook)(nil).DeliverBlockingEvent), ctx, u, e)
}

// DeliverNonBlockingEvent mocks base method.
func (m *MockEventWebHook) DeliverNonBlockingEvent(ctx context.Context, u *url.URL, e *event.Event) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeliverNonBlockingEvent", ctx, u, e)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeliverNonBlockingEvent indicates an expected call of DeliverNonBlockingEvent.
func (mr *MockEventWebHookMockRecorder) DeliverNonBlockingEvent(ctx, u, e interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeliverNonBlockingEvent", reflect.TypeOf((*MockEventWebHook)(nil).DeliverNonBlockingEvent), ctx, u, e)
}

// SupportURL mocks base method.
func (m *MockEventWebHook) SupportURL(u *url.URL) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SupportURL", u)
	ret0, _ := ret[0].(bool)
	return ret0
}

// SupportURL indicates an expected call of SupportURL.
func (mr *MockEventWebHookMockRecorder) SupportURL(u interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SupportURL", reflect.TypeOf((*MockEventWebHook)(nil).SupportURL), u)
}

// MockEventDenoHook is a mock of EventDenoHook interface.
type MockEventDenoHook struct {
	ctrl     *gomock.Controller
	recorder *MockEventDenoHookMockRecorder
}

// MockEventDenoHookMockRecorder is the mock recorder for MockEventDenoHook.
type MockEventDenoHookMockRecorder struct {
	mock *MockEventDenoHook
}

// NewMockEventDenoHook creates a new mock instance.
func NewMockEventDenoHook(ctrl *gomock.Controller) *MockEventDenoHook {
	mock := &MockEventDenoHook{ctrl: ctrl}
	mock.recorder = &MockEventDenoHookMockRecorder{mock}
	return mock
}

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

// DeliverBlockingEvent mocks base method.
func (m *MockEventDenoHook) DeliverBlockingEvent(ctx context.Context, u *url.URL, e *event.Event) (*event.HookResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeliverBlockingEvent", ctx, u, e)
	ret0, _ := ret[0].(*event.HookResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeliverBlockingEvent indicates an expected call of DeliverBlockingEvent.
func (mr *MockEventDenoHookMockRecorder) DeliverBlockingEvent(ctx, u, e interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeliverBlockingEvent", reflect.TypeOf((*MockEventDenoHook)(nil).DeliverBlockingEvent), ctx, u, e)
}

// DeliverNonBlockingEvent mocks base method.
func (m *MockEventDenoHook) DeliverNonBlockingEvent(ctx context.Context, u *url.URL, e *event.Event) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeliverNonBlockingEvent", ctx, u, e)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeliverNonBlockingEvent indicates an expected call of DeliverNonBlockingEvent.
func (mr *MockEventDenoHookMockRecorder) DeliverNonBlockingEvent(ctx, u, e interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeliverNonBlockingEvent", reflect.TypeOf((*MockEventDenoHook)(nil).DeliverNonBlockingEvent), ctx, u, e)
}

// SupportURL mocks base method.
func (m *MockEventDenoHook) SupportURL(u *url.URL) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SupportURL", u)
	ret0, _ := ret[0].(bool)
	return ret0
}

// SupportURL indicates an expected call of SupportURL.
func (mr *MockEventDenoHookMockRecorder) SupportURL(u interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SupportURL", reflect.TypeOf((*MockEventDenoHook)(nil).SupportURL), u)
}
