// Code generated by mockery; DO NOT EDIT.
// github.com/vektra/mockery
// template: testify

package alertmanagertest

import (
	"context"

	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
	"github.com/SigNoz/signoz/pkg/valuer"
	"github.com/prometheus/alertmanager/config"
	mock "github.com/stretchr/testify/mock"
)

// NewMockAlertmanager creates a new instance of MockAlertmanager. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewMockAlertmanager(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockAlertmanager {
	mock := &MockAlertmanager{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}

// MockAlertmanager is an autogenerated mock type for the Alertmanager type
type MockAlertmanager struct {
	mock.Mock
}

type MockAlertmanager_Expecter struct {
	mock *mock.Mock
}

func (_m *MockAlertmanager) EXPECT() *MockAlertmanager_Expecter {
	return &MockAlertmanager_Expecter{mock: &_m.Mock}
}

// Collect provides a mock function for the type MockAlertmanager
func (_mock *MockAlertmanager) Collect(context1 context.Context, uUID valuer.UUID) (map[string]any, error) {
	ret := _mock.Called(context1, uUID)

	if len(ret) == 0 {
		panic("no return value specified for Collect")
	}

	var r0 map[string]any
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, valuer.UUID) (map[string]any, error)); ok {
		return returnFunc(context1, uUID)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, valuer.UUID) map[string]any); ok {
		r0 = returnFunc(context1, uUID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[string]any)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, valuer.UUID) error); ok {
		r1 = returnFunc(context1, uUID)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockAlertmanager_Collect_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Collect'
type MockAlertmanager_Collect_Call struct {
	*mock.Call
}

// Collect is a helper method to define mock.On call
//   - context1 context.Context
//   - uUID valuer.UUID
func (_e *MockAlertmanager_Expecter) Collect(context1 interface{}, uUID interface{}) *MockAlertmanager_Collect_Call {
	return &MockAlertmanager_Collect_Call{Call: _e.mock.On("Collect", context1, uUID)}
}

func (_c *MockAlertmanager_Collect_Call) Run(run func(context1 context.Context, uUID valuer.UUID)) *MockAlertmanager_Collect_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 valuer.UUID
		if args[1] != nil {
			arg1 = args[1].(valuer.UUID)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockAlertmanager_Collect_Call) Return(stringToV map[string]any, err error) *MockAlertmanager_Collect_Call {
	_c.Call.Return(stringToV, err)
	return _c
}

func (_c *MockAlertmanager_Collect_Call) RunAndReturn(run func(context1 context.Context, uUID valuer.UUID) (map[string]any, error)) *MockAlertmanager_Collect_Call {
	_c.Call.Return(run)
	return _c
}

// CreateChannel provides a mock function for the type MockAlertmanager
func (_mock *MockAlertmanager) CreateChannel(context1 context.Context, s string, v alertmanagertypes.Receiver) (*alertmanagertypes.Channel, error) {
	ret := _mock.Called(context1, s, v)

	if len(ret) == 0 {
		panic("no return value specified for CreateChannel")
	}

	var r0 *alertmanagertypes.Channel
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, alertmanagertypes.Receiver) (*alertmanagertypes.Channel, error)); ok {
		return returnFunc(context1, s, v)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, alertmanagertypes.Receiver) *alertmanagertypes.Channel); ok {
		r0 = returnFunc(context1, s, v)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*alertmanagertypes.Channel)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, alertmanagertypes.Receiver) error); ok {
		r1 = returnFunc(context1, s, v)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockAlertmanager_CreateChannel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateChannel'
type MockAlertmanager_CreateChannel_Call struct {
	*mock.Call
}

// CreateChannel is a helper method to define mock.On call
//   - context1 context.Context
//   - s string
//   - v alertmanagertypes.Receiver
func (_e *MockAlertmanager_Expecter) CreateChannel(context1 interface{}, s interface{}, v interface{}) *MockAlertmanager_CreateChannel_Call {
	return &MockAlertmanager_CreateChannel_Call{Call: _e.mock.On("CreateChannel", context1, s, v)}
}

func (_c *MockAlertmanager_CreateChannel_Call) Run(run func(context1 context.Context, s string, v alertmanagertypes.Receiver)) *MockAlertmanager_CreateChannel_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 alertmanagertypes.Receiver
		if args[2] != nil {
			arg2 = args[2].(alertmanagertypes.Receiver)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAlertmanager_CreateChannel_Call) Return(channel *alertmanagertypes.Channel, err error) *MockAlertmanager_CreateChannel_Call {
	_c.Call.Return(channel, err)
	return _c
}

func (_c *MockAlertmanager_CreateChannel_Call) RunAndReturn(run func(context1 context.Context, s string, v alertmanagertypes.Receiver) (*alertmanagertypes.Channel, error)) *MockAlertmanager_CreateChannel_Call {
	_c.Call.Return(run)
	return _c
}

// CreateInhibitRules provides a mock function for the type MockAlertmanager
func (_mock *MockAlertmanager) CreateInhibitRules(ctx context.Context, orgID valuer.UUID, rules []config.InhibitRule) error {
	ret := _mock.Called(ctx, orgID, rules)

	if len(ret) == 0 {
		panic("no return value specified for CreateInhibitRules")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, valuer.UUID, []config.InhibitRule) error); ok {
		r0 = returnFunc(ctx, orgID, rules)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockAlertmanager_CreateInhibitRules_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateInhibitRules'
type MockAlertmanager_CreateInhibitRules_Call struct {
	*mock.Call
}

// CreateInhibitRules is a helper method to define mock.On call
//   - ctx context.Context
//   - orgID valuer.UUID
//   - rules []config.InhibitRule
func (_e *MockAlertmanager_Expecter) CreateInhibitRules(ctx interface{}, orgID interface{}, rules interface{}) *MockAlertmanager_CreateInhibitRules_Call {
	return &MockAlertmanager_CreateInhibitRules_Call{Call: _e.mock.On("CreateInhibitRules", ctx, orgID, rules)}
}

func (_c *MockAlertmanager_CreateInhibitRules_Call) Run(run func(ctx context.Context, orgID valuer.UUID, rules []config.InhibitRule)) *MockAlertmanager_CreateInhibitRules_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 valuer.UUID
		if args[1] != nil {
			arg1 = args[1].(valuer.UUID)
		}
		var arg2 []config.InhibitRule
		if args[2] != nil {
			arg2 = args[2].([]config.InhibitRule)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAlertmanager_CreateInhibitRules_Call) Return(err error) *MockAlertmanager_CreateInhibitRules_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockAlertmanager_CreateInhibitRules_Call) RunAndReturn(run func(ctx context.Context, orgID valuer.UUID, rules []config.InhibitRule) error) *MockAlertmanager_CreateInhibitRules_Call {
	_c.Call.Return(run)
	return _c
}

// CreateRoutePolicies provides a mock function for the type MockAlertmanager
func (_mock *MockAlertmanager) CreateRoutePolicies(ctx context.Context, routeRequests []*alertmanagertypes.PostableRoutePolicy) ([]*alertmanagertypes.GettableRoutePolicy, error) {
	ret := _mock.Called(ctx, routeRequests)

	if len(ret) == 0 {
		panic("no return value specified for CreateRoutePolicies")
	}

	var r0 []*alertmanagertypes.GettableRoutePolicy
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, []*alertmanagertypes.PostableRoutePolicy) ([]*alertmanagertypes.GettableRoutePolicy, error)); ok {
		return returnFunc(ctx, routeRequests)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, []*alertmanagertypes.PostableRoutePolicy) []*alertmanagertypes.GettableRoutePolicy); ok {
		r0 = returnFunc(ctx, routeRequests)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*alertmanagertypes.GettableRoutePolicy)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, []*alertmanagertypes.PostableRoutePolicy) error); ok {
		r1 = returnFunc(ctx, routeRequests)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockAlertmanager_CreateRoutePolicies_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateRoutePolicies'
type MockAlertmanager_CreateRoutePolicies_Call struct {
	*mock.Call
}

// CreateRoutePolicies is a helper method to define mock.On call
//   - ctx context.Context
//   - routeRequests []*alertmanagertypes.PostableRoutePolicy
func (_e *MockAlertmanager_Expecter) CreateRoutePolicies(ctx interface{}, routeRequests interface{}) *MockAlertmanager_CreateRoutePolicies_Call {
	return &MockAlertmanager_CreateRoutePolicies_Call{Call: _e.mock.On("CreateRoutePolicies", ctx, routeRequests)}
}

func (_c *MockAlertmanager_CreateRoutePolicies_Call) Run(run func(ctx context.Context, routeRequests []*alertmanagertypes.PostableRoutePolicy)) *MockAlertmanager_CreateRoutePolicies_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 []*alertmanagertypes.PostableRoutePolicy
		if args[1] != nil {
			arg1 = args[1].([]*alertmanagertypes.PostableRoutePolicy)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockAlertmanager_CreateRoutePolicies_Call) Return(gettableRoutePolicys []*alertmanagertypes.GettableRoutePolicy, err error) *MockAlertmanager_CreateRoutePolicies_Call {
	_c.Call.Return(gettableRoutePolicys, err)
	return _c
}

func (_c *MockAlertmanager_CreateRoutePolicies_Call) RunAndReturn(run func(ctx context.Context, routeRequests []*alertmanagertypes.PostableRoutePolicy) ([]*alertmanagertypes.GettableRoutePolicy, error)) *MockAlertmanager_CreateRoutePolicies_Call {
	_c.Call.Return(run)
	return _c
}

// CreateRoutePolicy provides a mock function for the type MockAlertmanager
func (_mock *MockAlertmanager) CreateRoutePolicy(ctx context.Context, route *alertmanagertypes.PostableRoutePolicy) (*alertmanagertypes.GettableRoutePolicy, error) {
	ret := _mock.Called(ctx, route)

	if len(ret) == 0 {
		panic("no return value specified for CreateRoutePolicy")
	}

	var r0 *alertmanagertypes.GettableRoutePolicy
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *alertmanagertypes.PostableRoutePolicy) (*alertmanagertypes.GettableRoutePolicy, error)); ok {
		return returnFunc(ctx, route)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *alertmanagertypes.PostableRoutePolicy) *alertmanagertypes.GettableRoutePolicy); ok {
		r0 = returnFunc(ctx, route)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*alertmanagertypes.GettableRoutePolicy)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *alertmanagertypes.PostableRoutePolicy) error); ok {
		r1 = returnFunc(ctx, route)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockAlertmanager_CreateRoutePolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateRoutePolicy'
type MockAlertmanager_CreateRoutePolicy_Call struct {
	*mock.Call
}

// CreateRoutePolicy is a helper method to define mock.On call
//   - ctx context.Context
//   - route *alertmanagertypes.PostableRoutePolicy
func (_e *MockAlertmanager_Expecter) CreateRoutePolicy(ctx interface{}, route interface{}) *MockAlertmanager_CreateRoutePolicy_Call {
	return &MockAlertmanager_CreateRoutePolicy_Call{Call: _e.mock.On("CreateRoutePolicy", ctx, route)}
}

func (_c *MockAlertmanager_CreateRoutePolicy_Call) Run(run func(ctx context.Context, route *alertmanagertypes.PostableRoutePolicy)) *MockAlertmanager_CreateRoutePolicy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *alertmanagertypes.PostableRoutePolicy
		if args[1] != nil {
			arg1 = args[1].(*alertmanagertypes.PostableRoutePolicy)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockAlertmanager_CreateRoutePolicy_Call) Return(gettableRoutePolicy *alertmanagertypes.GettableRoutePolicy, err error) *MockAlertmanager_CreateRoutePolicy_Call {
	_c.Call.Return(gettableRoutePolicy, err)
	return _c
}

func (_c *MockAlertmanager_CreateRoutePolicy_Call) RunAndReturn(run func(ctx context.Context, route *alertmanagertypes.PostableRoutePolicy) (*alertmanagertypes.GettableRoutePolicy, error)) *MockAlertmanager_CreateRoutePolicy_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteAllInhibitRulesByRuleId provides a mock function for the type MockAlertmanager
func (_mock *MockAlertmanager) DeleteAllInhibitRulesByRuleId(ctx context.Context, orgID valuer.UUID, ruleId string) error {
	ret := _mock.Called(ctx, orgID, ruleId)

	if len(ret) == 0 {
		panic("no return value specified for DeleteAllInhibitRulesByRuleId")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, valuer.UUID, string) error); ok {
		r0 = returnFunc(ctx, orgID, ruleId)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockAlertmanager_DeleteAllInhibitRulesByRuleId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteAllInhibitRulesByRuleId'
type MockAlertmanager_DeleteAllInhibitRulesByRuleId_Call struct {
	*mock.Call
}

// DeleteAllInhibitRulesByRuleId is a helper method to define mock.On call
//   - ctx context.Context
//   - orgID valuer.UUID
//   - ruleId string
func (_e *MockAlertmanager_Expecter) DeleteAllInhibitRulesByRuleId(ctx interface{}, orgID interface{}, ruleId interface{}) *MockAlertmanager_DeleteAllInhibitRulesByRuleId_Call {
	return &MockAlertmanager_DeleteAllInhibitRulesByRuleId_Call{Call: _e.mock.On("DeleteAllInhibitRulesByRuleId", ctx, orgID, ruleId)}
}

func (_c *MockAlertmanager_DeleteAllInhibitRulesByRuleId_Call) Run(run func(ctx context.Context, orgID valuer.UUID, ruleId string)) *MockAlertmanager_DeleteAllInhibitRulesByRuleId_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 valuer.UUID
		if args[1] != nil {
			arg1 = args[1].(valuer.UUID)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAlertmanager_DeleteAllInhibitRulesByRuleId_Call) Return(err error) *MockAlertmanager_DeleteAllInhibitRulesByRuleId_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockAlertmanager_DeleteAllInhibitRulesByRuleId_Call) RunAndReturn(run func(ctx context.Context, orgID valuer.UUID, ruleId string) error) *MockAlertmanager_DeleteAllInhibitRulesByRuleId_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteAllRoutePoliciesByRuleId provides a mock function for the type MockAlertmanager
func (_mock *MockAlertmanager) DeleteAllRoutePoliciesByRuleId(ctx context.Context, ruleId string) error {
	ret := _mock.Called(ctx, ruleId)

	if len(ret) == 0 {
		panic("no return value specified for DeleteAllRoutePoliciesByRuleId")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
		r0 = returnFunc(ctx, ruleId)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockAlertmanager_DeleteAllRoutePoliciesByRuleId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteAllRoutePoliciesByRuleId'
type MockAlertmanager_DeleteAllRoutePoliciesByRuleId_Call struct {
	*mock.Call
}

// DeleteAllRoutePoliciesByRuleId is a helper method to define mock.On call
//   - ctx context.Context
//   - ruleId string
func (_e *MockAlertmanager_Expecter) DeleteAllRoutePoliciesByRuleId(ctx interface{}, ruleId interface{}) *MockAlertmanager_DeleteAllRoutePoliciesByRuleId_Call {
	return &MockAlertmanager_DeleteAllRoutePoliciesByRuleId_Call{Call: _e.mock.On("DeleteAllRoutePoliciesByRuleId", ctx, ruleId)}
}

func (_c *MockAlertmanager_DeleteAllRoutePoliciesByRuleId_Call) Run(run func(ctx context.Context, ruleId string)) *MockAlertmanager_DeleteAllRoutePoliciesByRuleId_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockAlertmanager_DeleteAllRoutePoliciesByRuleId_Call) Return(err error) *MockAlertmanager_DeleteAllRoutePoliciesByRuleId_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockAlertmanager_DeleteAllRoutePoliciesByRuleId_Call) RunAndReturn(run func(ctx context.Context, ruleId string) error) *MockAlertmanager_DeleteAllRoutePoliciesByRuleId_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteChannelByID provides a mock function for the type MockAlertmanager
func (_mock *MockAlertmanager) DeleteChannelByID(context1 context.Context, s string, uUID valuer.UUID) error {
	ret := _mock.Called(context1, s, uUID)

	if len(ret) == 0 {
		panic("no return value specified for DeleteChannelByID")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, valuer.UUID) error); ok {
		r0 = returnFunc(context1, s, uUID)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockAlertmanager_DeleteChannelByID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteChannelByID'
type MockAlertmanager_DeleteChannelByID_Call struct {
	*mock.Call
}

// DeleteChannelByID is a helper method to define mock.On call
//   - context1 context.Context
//   - s string
//   - uUID valuer.UUID
func (_e *MockAlertmanager_Expecter) DeleteChannelByID(context1 interface{}, s interface{}, uUID interface{}) *MockAlertmanager_DeleteChannelByID_Call {
	return &MockAlertmanager_DeleteChannelByID_Call{Call: _e.mock.On("DeleteChannelByID", context1, s, uUID)}
}

func (_c *MockAlertmanager_DeleteChannelByID_Call) Run(run func(context1 context.Context, s string, uUID valuer.UUID)) *MockAlertmanager_DeleteChannelByID_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 valuer.UUID
		if args[2] != nil {
			arg2 = args[2].(valuer.UUID)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAlertmanager_DeleteChannelByID_Call) Return(err error) *MockAlertmanager_DeleteChannelByID_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockAlertmanager_DeleteChannelByID_Call) RunAndReturn(run func(context1 context.Context, s string, uUID valuer.UUID) error) *MockAlertmanager_DeleteChannelByID_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteNotificationConfig provides a mock function for the type MockAlertmanager
func (_mock *MockAlertmanager) DeleteNotificationConfig(ctx context.Context, orgID valuer.UUID, ruleId string) error {
	ret := _mock.Called(ctx, orgID, ruleId)

	if len(ret) == 0 {
		panic("no return value specified for DeleteNotificationConfig")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, valuer.UUID, string) error); ok {
		r0 = returnFunc(ctx, orgID, ruleId)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockAlertmanager_DeleteNotificationConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteNotificationConfig'
type MockAlertmanager_DeleteNotificationConfig_Call struct {
	*mock.Call
}

// DeleteNotificationConfig is a helper method to define mock.On call
//   - ctx context.Context
//   - orgID valuer.UUID
//   - ruleId string
func (_e *MockAlertmanager_Expecter) DeleteNotificationConfig(ctx interface{}, orgID interface{}, ruleId interface{}) *MockAlertmanager_DeleteNotificationConfig_Call {
	return &MockAlertmanager_DeleteNotificationConfig_Call{Call: _e.mock.On("DeleteNotificationConfig", ctx, orgID, ruleId)}
}

func (_c *MockAlertmanager_DeleteNotificationConfig_Call) Run(run func(ctx context.Context, orgID valuer.UUID, ruleId string)) *MockAlertmanager_DeleteNotificationConfig_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 valuer.UUID
		if args[1] != nil {
			arg1 = args[1].(valuer.UUID)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAlertmanager_DeleteNotificationConfig_Call) Return(err error) *MockAlertmanager_DeleteNotificationConfig_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockAlertmanager_DeleteNotificationConfig_Call) RunAndReturn(run func(ctx context.Context, orgID valuer.UUID, ruleId string) error) *MockAlertmanager_DeleteNotificationConfig_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteRoutePolicyByID provides a mock function for the type MockAlertmanager
func (_mock *MockAlertmanager) DeleteRoutePolicyByID(ctx context.Context, routeID string) error {
	ret := _mock.Called(ctx, routeID)

	if len(ret) == 0 {
		panic("no return value specified for DeleteRoutePolicyByID")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
		r0 = returnFunc(ctx, routeID)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockAlertmanager_DeleteRoutePolicyByID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteRoutePolicyByID'
type MockAlertmanager_DeleteRoutePolicyByID_Call struct {
	*mock.Call
}

// DeleteRoutePolicyByID is a helper method to define mock.On call
//   - ctx context.Context
//   - routeID string
func (_e *MockAlertmanager_Expecter) DeleteRoutePolicyByID(ctx interface{}, routeID interface{}) *MockAlertmanager_DeleteRoutePolicyByID_Call {
	return &MockAlertmanager_DeleteRoutePolicyByID_Call{Call: _e.mock.On("DeleteRoutePolicyByID", ctx, routeID)}
}

func (_c *MockAlertmanager_DeleteRoutePolicyByID_Call) Run(run func(ctx context.Context, routeID string)) *MockAlertmanager_DeleteRoutePolicyByID_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockAlertmanager_DeleteRoutePolicyByID_Call) Return(err error) *MockAlertmanager_DeleteRoutePolicyByID_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockAlertmanager_DeleteRoutePolicyByID_Call) RunAndReturn(run func(ctx context.Context, routeID string) error) *MockAlertmanager_DeleteRoutePolicyByID_Call {
	_c.Call.Return(run)
	return _c
}

// GetAlerts provides a mock function for the type MockAlertmanager
func (_mock *MockAlertmanager) GetAlerts(context1 context.Context, s string, gettableAlertsParams alertmanagertypes.GettableAlertsParams) (alertmanagertypes.DeprecatedGettableAlerts, error) {
	ret := _mock.Called(context1, s, gettableAlertsParams)

	if len(ret) == 0 {
		panic("no return value specified for GetAlerts")
	}

	var r0 alertmanagertypes.DeprecatedGettableAlerts
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, alertmanagertypes.GettableAlertsParams) (alertmanagertypes.DeprecatedGettableAlerts, error)); ok {
		return returnFunc(context1, s, gettableAlertsParams)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, alertmanagertypes.GettableAlertsParams) alertmanagertypes.DeprecatedGettableAlerts); ok {
		r0 = returnFunc(context1, s, gettableAlertsParams)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(alertmanagertypes.DeprecatedGettableAlerts)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, alertmanagertypes.GettableAlertsParams) error); ok {
		r1 = returnFunc(context1, s, gettableAlertsParams)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockAlertmanager_GetAlerts_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAlerts'
type MockAlertmanager_GetAlerts_Call struct {
	*mock.Call
}

// GetAlerts is a helper method to define mock.On call
//   - context1 context.Context
//   - s string
//   - gettableAlertsParams alertmanagertypes.GettableAlertsParams
func (_e *MockAlertmanager_Expecter) GetAlerts(context1 interface{}, s interface{}, gettableAlertsParams interface{}) *MockAlertmanager_GetAlerts_Call {
	return &MockAlertmanager_GetAlerts_Call{Call: _e.mock.On("GetAlerts", context1, s, gettableAlertsParams)}
}

func (_c *MockAlertmanager_GetAlerts_Call) Run(run func(context1 context.Context, s string, gettableAlertsParams alertmanagertypes.GettableAlertsParams)) *MockAlertmanager_GetAlerts_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 alertmanagertypes.GettableAlertsParams
		if args[2] != nil {
			arg2 = args[2].(alertmanagertypes.GettableAlertsParams)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAlertmanager_GetAlerts_Call) Return(v alertmanagertypes.DeprecatedGettableAlerts, err error) *MockAlertmanager_GetAlerts_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *MockAlertmanager_GetAlerts_Call) RunAndReturn(run func(context1 context.Context, s string, gettableAlertsParams alertmanagertypes.GettableAlertsParams) (alertmanagertypes.DeprecatedGettableAlerts, error)) *MockAlertmanager_GetAlerts_Call {
	_c.Call.Return(run)
	return _c
}

// GetAllRoutePolicies provides a mock function for the type MockAlertmanager
func (_mock *MockAlertmanager) GetAllRoutePolicies(ctx context.Context) ([]*alertmanagertypes.GettableRoutePolicy, error) {
	ret := _mock.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for GetAllRoutePolicies")
	}

	var r0 []*alertmanagertypes.GettableRoutePolicy
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context) ([]*alertmanagertypes.GettableRoutePolicy, error)); ok {
		return returnFunc(ctx)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context) []*alertmanagertypes.GettableRoutePolicy); ok {
		r0 = returnFunc(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*alertmanagertypes.GettableRoutePolicy)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = returnFunc(ctx)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockAlertmanager_GetAllRoutePolicies_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllRoutePolicies'
type MockAlertmanager_GetAllRoutePolicies_Call struct {
	*mock.Call
}

// GetAllRoutePolicies is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockAlertmanager_Expecter) GetAllRoutePolicies(ctx interface{}) *MockAlertmanager_GetAllRoutePolicies_Call {
	return &MockAlertmanager_GetAllRoutePolicies_Call{Call: _e.mock.On("GetAllRoutePolicies", ctx)}
}

func (_c *MockAlertmanager_GetAllRoutePolicies_Call) Run(run func(ctx context.Context)) *MockAlertmanager_GetAllRoutePolicies_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockAlertmanager_GetAllRoutePolicies_Call) Return(gettableRoutePolicys []*alertmanagertypes.GettableRoutePolicy, err error) *MockAlertmanager_GetAllRoutePolicies_Call {
	_c.Call.Return(gettableRoutePolicys, err)
	return _c
}

func (_c *MockAlertmanager_GetAllRoutePolicies_Call) RunAndReturn(run func(ctx context.Context) ([]*alertmanagertypes.GettableRoutePolicy, error)) *MockAlertmanager_GetAllRoutePolicies_Call {
	_c.Call.Return(run)
	return _c
}

// GetChannelByID provides a mock function for the type MockAlertmanager
func (_mock *MockAlertmanager) GetChannelByID(context1 context.Context, s string, uUID valuer.UUID) (*alertmanagertypes.Channel, error) {
	ret := _mock.Called(context1, s, uUID)

	if len(ret) == 0 {
		panic("no return value specified for GetChannelByID")
	}

	var r0 *alertmanagertypes.Channel
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, valuer.UUID) (*alertmanagertypes.Channel, error)); ok {
		return returnFunc(context1, s, uUID)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, valuer.UUID) *alertmanagertypes.Channel); ok {
		r0 = returnFunc(context1, s, uUID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*alertmanagertypes.Channel)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, valuer.UUID) error); ok {
		r1 = returnFunc(context1, s, uUID)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockAlertmanager_GetChannelByID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetChannelByID'
type MockAlertmanager_GetChannelByID_Call struct {
	*mock.Call
}

// GetChannelByID is a helper method to define mock.On call
//   - context1 context.Context
//   - s string
//   - uUID valuer.UUID
func (_e *MockAlertmanager_Expecter) GetChannelByID(context1 interface{}, s interface{}, uUID interface{}) *MockAlertmanager_GetChannelByID_Call {
	return &MockAlertmanager_GetChannelByID_Call{Call: _e.mock.On("GetChannelByID", context1, s, uUID)}
}

func (_c *MockAlertmanager_GetChannelByID_Call) Run(run func(context1 context.Context, s string, uUID valuer.UUID)) *MockAlertmanager_GetChannelByID_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 valuer.UUID
		if args[2] != nil {
			arg2 = args[2].(valuer.UUID)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAlertmanager_GetChannelByID_Call) Return(channel *alertmanagertypes.Channel, err error) *MockAlertmanager_GetChannelByID_Call {
	_c.Call.Return(channel, err)
	return _c
}

func (_c *MockAlertmanager_GetChannelByID_Call) RunAndReturn(run func(context1 context.Context, s string, uUID valuer.UUID) (*alertmanagertypes.Channel, error)) *MockAlertmanager_GetChannelByID_Call {
	_c.Call.Return(run)
	return _c
}

// GetConfig provides a mock function for the type MockAlertmanager
func (_mock *MockAlertmanager) GetConfig(context1 context.Context, s string) (*alertmanagertypes.Config, error) {
	ret := _mock.Called(context1, s)

	if len(ret) == 0 {
		panic("no return value specified for GetConfig")
	}

	var r0 *alertmanagertypes.Config
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*alertmanagertypes.Config, error)); ok {
		return returnFunc(context1, s)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) *alertmanagertypes.Config); ok {
		r0 = returnFunc(context1, s)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*alertmanagertypes.Config)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(context1, s)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockAlertmanager_GetConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetConfig'
type MockAlertmanager_GetConfig_Call struct {
	*mock.Call
}

// GetConfig is a helper method to define mock.On call
//   - context1 context.Context
//   - s string
func (_e *MockAlertmanager_Expecter) GetConfig(context1 interface{}, s interface{}) *MockAlertmanager_GetConfig_Call {
	return &MockAlertmanager_GetConfig_Call{Call: _e.mock.On("GetConfig", context1, s)}
}

func (_c *MockAlertmanager_GetConfig_Call) Run(run func(context1 context.Context, s string)) *MockAlertmanager_GetConfig_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockAlertmanager_GetConfig_Call) Return(config1 *alertmanagertypes.Config, err error) *MockAlertmanager_GetConfig_Call {
	_c.Call.Return(config1, err)
	return _c
}

func (_c *MockAlertmanager_GetConfig_Call) RunAndReturn(run func(context1 context.Context, s string) (*alertmanagertypes.Config, error)) *MockAlertmanager_GetConfig_Call {
	_c.Call.Return(run)
	return _c
}

// GetRoutePolicyByID provides a mock function for the type MockAlertmanager
func (_mock *MockAlertmanager) GetRoutePolicyByID(ctx context.Context, routeID string) (*alertmanagertypes.GettableRoutePolicy, error) {
	ret := _mock.Called(ctx, routeID)

	if len(ret) == 0 {
		panic("no return value specified for GetRoutePolicyByID")
	}

	var r0 *alertmanagertypes.GettableRoutePolicy
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*alertmanagertypes.GettableRoutePolicy, error)); ok {
		return returnFunc(ctx, routeID)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) *alertmanagertypes.GettableRoutePolicy); ok {
		r0 = returnFunc(ctx, routeID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*alertmanagertypes.GettableRoutePolicy)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, routeID)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockAlertmanager_GetRoutePolicyByID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRoutePolicyByID'
type MockAlertmanager_GetRoutePolicyByID_Call struct {
	*mock.Call
}

// GetRoutePolicyByID is a helper method to define mock.On call
//   - ctx context.Context
//   - routeID string
func (_e *MockAlertmanager_Expecter) GetRoutePolicyByID(ctx interface{}, routeID interface{}) *MockAlertmanager_GetRoutePolicyByID_Call {
	return &MockAlertmanager_GetRoutePolicyByID_Call{Call: _e.mock.On("GetRoutePolicyByID", ctx, routeID)}
}

func (_c *MockAlertmanager_GetRoutePolicyByID_Call) Run(run func(ctx context.Context, routeID string)) *MockAlertmanager_GetRoutePolicyByID_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockAlertmanager_GetRoutePolicyByID_Call) Return(gettableRoutePolicy *alertmanagertypes.GettableRoutePolicy, err error) *MockAlertmanager_GetRoutePolicyByID_Call {
	_c.Call.Return(gettableRoutePolicy, err)
	return _c
}

func (_c *MockAlertmanager_GetRoutePolicyByID_Call) RunAndReturn(run func(ctx context.Context, routeID string) (*alertmanagertypes.GettableRoutePolicy, error)) *MockAlertmanager_GetRoutePolicyByID_Call {
	_c.Call.Return(run)
	return _c
}

// ListAllChannels provides a mock function for the type MockAlertmanager
func (_mock *MockAlertmanager) ListAllChannels(context1 context.Context) ([]*alertmanagertypes.Channel, error) {
	ret := _mock.Called(context1)

	if len(ret) == 0 {
		panic("no return value specified for ListAllChannels")
	}

	var r0 []*alertmanagertypes.Channel
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context) ([]*alertmanagertypes.Channel, error)); ok {
		return returnFunc(context1)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context) []*alertmanagertypes.Channel); ok {
		r0 = returnFunc(context1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*alertmanagertypes.Channel)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = returnFunc(context1)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockAlertmanager_ListAllChannels_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAllChannels'
type MockAlertmanager_ListAllChannels_Call struct {
	*mock.Call
}

// ListAllChannels is a helper method to define mock.On call
//   - context1 context.Context
func (_e *MockAlertmanager_Expecter) ListAllChannels(context1 interface{}) *MockAlertmanager_ListAllChannels_Call {
	return &MockAlertmanager_ListAllChannels_Call{Call: _e.mock.On("ListAllChannels", context1)}
}

func (_c *MockAlertmanager_ListAllChannels_Call) Run(run func(context1 context.Context)) *MockAlertmanager_ListAllChannels_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockAlertmanager_ListAllChannels_Call) Return(channels []*alertmanagertypes.Channel, err error) *MockAlertmanager_ListAllChannels_Call {
	_c.Call.Return(channels, err)
	return _c
}

func (_c *MockAlertmanager_ListAllChannels_Call) RunAndReturn(run func(context1 context.Context) ([]*alertmanagertypes.Channel, error)) *MockAlertmanager_ListAllChannels_Call {
	_c.Call.Return(run)
	return _c
}

// ListChannels provides a mock function for the type MockAlertmanager
func (_mock *MockAlertmanager) ListChannels(context1 context.Context, s string) ([]*alertmanagertypes.Channel, error) {
	ret := _mock.Called(context1, s)

	if len(ret) == 0 {
		panic("no return value specified for ListChannels")
	}

	var r0 []*alertmanagertypes.Channel
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]*alertmanagertypes.Channel, error)); ok {
		return returnFunc(context1, s)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []*alertmanagertypes.Channel); ok {
		r0 = returnFunc(context1, s)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*alertmanagertypes.Channel)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(context1, s)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockAlertmanager_ListChannels_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListChannels'
type MockAlertmanager_ListChannels_Call struct {
	*mock.Call
}

// ListChannels is a helper method to define mock.On call
//   - context1 context.Context
//   - s string
func (_e *MockAlertmanager_Expecter) ListChannels(context1 interface{}, s interface{}) *MockAlertmanager_ListChannels_Call {
	return &MockAlertmanager_ListChannels_Call{Call: _e.mock.On("ListChannels", context1, s)}
}

func (_c *MockAlertmanager_ListChannels_Call) Run(run func(context1 context.Context, s string)) *MockAlertmanager_ListChannels_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockAlertmanager_ListChannels_Call) Return(channels []*alertmanagertypes.Channel, err error) *MockAlertmanager_ListChannels_Call {
	_c.Call.Return(channels, err)
	return _c
}

func (_c *MockAlertmanager_ListChannels_Call) RunAndReturn(run func(context1 context.Context, s string) ([]*alertmanagertypes.Channel, error)) *MockAlertmanager_ListChannels_Call {
	_c.Call.Return(run)
	return _c
}

// PutAlerts provides a mock function for the type MockAlertmanager
func (_mock *MockAlertmanager) PutAlerts(context1 context.Context, s string, v alertmanagertypes.PostableAlerts) error {
	ret := _mock.Called(context1, s, v)

	if len(ret) == 0 {
		panic("no return value specified for PutAlerts")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, alertmanagertypes.PostableAlerts) error); ok {
		r0 = returnFunc(context1, s, v)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockAlertmanager_PutAlerts_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutAlerts'
type MockAlertmanager_PutAlerts_Call struct {
	*mock.Call
}

// PutAlerts is a helper method to define mock.On call
//   - context1 context.Context
//   - s string
//   - v alertmanagertypes.PostableAlerts
func (_e *MockAlertmanager_Expecter) PutAlerts(context1 interface{}, s interface{}, v interface{}) *MockAlertmanager_PutAlerts_Call {
	return &MockAlertmanager_PutAlerts_Call{Call: _e.mock.On("PutAlerts", context1, s, v)}
}

func (_c *MockAlertmanager_PutAlerts_Call) Run(run func(context1 context.Context, s string, v alertmanagertypes.PostableAlerts)) *MockAlertmanager_PutAlerts_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 alertmanagertypes.PostableAlerts
		if args[2] != nil {
			arg2 = args[2].(alertmanagertypes.PostableAlerts)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAlertmanager_PutAlerts_Call) Return(err error) *MockAlertmanager_PutAlerts_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockAlertmanager_PutAlerts_Call) RunAndReturn(run func(context1 context.Context, s string, v alertmanagertypes.PostableAlerts) error) *MockAlertmanager_PutAlerts_Call {
	_c.Call.Return(run)
	return _c
}

// SetConfig provides a mock function for the type MockAlertmanager
func (_mock *MockAlertmanager) SetConfig(context1 context.Context, config1 *alertmanagertypes.Config) error {
	ret := _mock.Called(context1, config1)

	if len(ret) == 0 {
		panic("no return value specified for SetConfig")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *alertmanagertypes.Config) error); ok {
		r0 = returnFunc(context1, config1)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockAlertmanager_SetConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetConfig'
type MockAlertmanager_SetConfig_Call struct {
	*mock.Call
}

// SetConfig is a helper method to define mock.On call
//   - context1 context.Context
//   - config1 *alertmanagertypes.Config
func (_e *MockAlertmanager_Expecter) SetConfig(context1 interface{}, config1 interface{}) *MockAlertmanager_SetConfig_Call {
	return &MockAlertmanager_SetConfig_Call{Call: _e.mock.On("SetConfig", context1, config1)}
}

func (_c *MockAlertmanager_SetConfig_Call) Run(run func(context1 context.Context, config1 *alertmanagertypes.Config)) *MockAlertmanager_SetConfig_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *alertmanagertypes.Config
		if args[1] != nil {
			arg1 = args[1].(*alertmanagertypes.Config)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockAlertmanager_SetConfig_Call) Return(err error) *MockAlertmanager_SetConfig_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockAlertmanager_SetConfig_Call) RunAndReturn(run func(context1 context.Context, config1 *alertmanagertypes.Config) error) *MockAlertmanager_SetConfig_Call {
	_c.Call.Return(run)
	return _c
}

// SetDefaultConfig provides a mock function for the type MockAlertmanager
func (_mock *MockAlertmanager) SetDefaultConfig(context1 context.Context, s string) error {
	ret := _mock.Called(context1, s)

	if len(ret) == 0 {
		panic("no return value specified for SetDefaultConfig")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
		r0 = returnFunc(context1, s)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockAlertmanager_SetDefaultConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetDefaultConfig'
type MockAlertmanager_SetDefaultConfig_Call struct {
	*mock.Call
}

// SetDefaultConfig is a helper method to define mock.On call
//   - context1 context.Context
//   - s string
func (_e *MockAlertmanager_Expecter) SetDefaultConfig(context1 interface{}, s interface{}) *MockAlertmanager_SetDefaultConfig_Call {
	return &MockAlertmanager_SetDefaultConfig_Call{Call: _e.mock.On("SetDefaultConfig", context1, s)}
}

func (_c *MockAlertmanager_SetDefaultConfig_Call) Run(run func(context1 context.Context, s string)) *MockAlertmanager_SetDefaultConfig_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockAlertmanager_SetDefaultConfig_Call) Return(err error) *MockAlertmanager_SetDefaultConfig_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockAlertmanager_SetDefaultConfig_Call) RunAndReturn(run func(context1 context.Context, s string) error) *MockAlertmanager_SetDefaultConfig_Call {
	_c.Call.Return(run)
	return _c
}

// SetNotificationConfig provides a mock function for the type MockAlertmanager
func (_mock *MockAlertmanager) SetNotificationConfig(ctx context.Context, orgID valuer.UUID, ruleId string, config1 *alertmanagertypes.NotificationConfig) error {
	ret := _mock.Called(ctx, orgID, ruleId, config1)

	if len(ret) == 0 {
		panic("no return value specified for SetNotificationConfig")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, valuer.UUID, string, *alertmanagertypes.NotificationConfig) error); ok {
		r0 = returnFunc(ctx, orgID, ruleId, config1)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockAlertmanager_SetNotificationConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetNotificationConfig'
type MockAlertmanager_SetNotificationConfig_Call struct {
	*mock.Call
}

// SetNotificationConfig is a helper method to define mock.On call
//   - ctx context.Context
//   - orgID valuer.UUID
//   - ruleId string
//   - config1 *alertmanagertypes.NotificationConfig
func (_e *MockAlertmanager_Expecter) SetNotificationConfig(ctx interface{}, orgID interface{}, ruleId interface{}, config1 interface{}) *MockAlertmanager_SetNotificationConfig_Call {
	return &MockAlertmanager_SetNotificationConfig_Call{Call: _e.mock.On("SetNotificationConfig", ctx, orgID, ruleId, config1)}
}

func (_c *MockAlertmanager_SetNotificationConfig_Call) Run(run func(ctx context.Context, orgID valuer.UUID, ruleId string, config1 *alertmanagertypes.NotificationConfig)) *MockAlertmanager_SetNotificationConfig_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 valuer.UUID
		if args[1] != nil {
			arg1 = args[1].(valuer.UUID)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 *alertmanagertypes.NotificationConfig
		if args[3] != nil {
			arg3 = args[3].(*alertmanagertypes.NotificationConfig)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *MockAlertmanager_SetNotificationConfig_Call) Return(err error) *MockAlertmanager_SetNotificationConfig_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockAlertmanager_SetNotificationConfig_Call) RunAndReturn(run func(ctx context.Context, orgID valuer.UUID, ruleId string, config1 *alertmanagertypes.NotificationConfig) error) *MockAlertmanager_SetNotificationConfig_Call {
	_c.Call.Return(run)
	return _c
}

// Start provides a mock function for the type MockAlertmanager
func (_mock *MockAlertmanager) Start(context1 context.Context) error {
	ret := _mock.Called(context1)

	if len(ret) == 0 {
		panic("no return value specified for Start")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
		r0 = returnFunc(context1)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockAlertmanager_Start_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Start'
type MockAlertmanager_Start_Call struct {
	*mock.Call
}

// Start is a helper method to define mock.On call
//   - context1 context.Context
func (_e *MockAlertmanager_Expecter) Start(context1 interface{}) *MockAlertmanager_Start_Call {
	return &MockAlertmanager_Start_Call{Call: _e.mock.On("Start", context1)}
}

func (_c *MockAlertmanager_Start_Call) Run(run func(context1 context.Context)) *MockAlertmanager_Start_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockAlertmanager_Start_Call) Return(err error) *MockAlertmanager_Start_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockAlertmanager_Start_Call) RunAndReturn(run func(context1 context.Context) error) *MockAlertmanager_Start_Call {
	_c.Call.Return(run)
	return _c
}

// Stop provides a mock function for the type MockAlertmanager
func (_mock *MockAlertmanager) Stop(context1 context.Context) error {
	ret := _mock.Called(context1)

	if len(ret) == 0 {
		panic("no return value specified for Stop")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
		r0 = returnFunc(context1)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockAlertmanager_Stop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Stop'
type MockAlertmanager_Stop_Call struct {
	*mock.Call
}

// Stop is a helper method to define mock.On call
//   - context1 context.Context
func (_e *MockAlertmanager_Expecter) Stop(context1 interface{}) *MockAlertmanager_Stop_Call {
	return &MockAlertmanager_Stop_Call{Call: _e.mock.On("Stop", context1)}
}

func (_c *MockAlertmanager_Stop_Call) Run(run func(context1 context.Context)) *MockAlertmanager_Stop_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockAlertmanager_Stop_Call) Return(err error) *MockAlertmanager_Stop_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockAlertmanager_Stop_Call) RunAndReturn(run func(context1 context.Context) error) *MockAlertmanager_Stop_Call {
	_c.Call.Return(run)
	return _c
}

// TestAlert provides a mock function for the type MockAlertmanager
func (_mock *MockAlertmanager) TestAlert(ctx context.Context, orgID string, ruleID string, receiversMap map[*alertmanagertypes.PostableAlert][]string) error {
	ret := _mock.Called(ctx, orgID, ruleID, receiversMap)

	if len(ret) == 0 {
		panic("no return value specified for TestAlert")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, map[*alertmanagertypes.PostableAlert][]string) error); ok {
		r0 = returnFunc(ctx, orgID, ruleID, receiversMap)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockAlertmanager_TestAlert_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TestAlert'
type MockAlertmanager_TestAlert_Call struct {
	*mock.Call
}

// TestAlert is a helper method to define mock.On call
//   - ctx context.Context
//   - orgID string
//   - ruleID string
//   - receiversMap map[*alertmanagertypes.PostableAlert][]string
func (_e *MockAlertmanager_Expecter) TestAlert(ctx interface{}, orgID interface{}, ruleID interface{}, receiversMap interface{}) *MockAlertmanager_TestAlert_Call {
	return &MockAlertmanager_TestAlert_Call{Call: _e.mock.On("TestAlert", ctx, orgID, ruleID, receiversMap)}
}

func (_c *MockAlertmanager_TestAlert_Call) Run(run func(ctx context.Context, orgID string, ruleID string, receiversMap map[*alertmanagertypes.PostableAlert][]string)) *MockAlertmanager_TestAlert_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 map[*alertmanagertypes.PostableAlert][]string
		if args[3] != nil {
			arg3 = args[3].(map[*alertmanagertypes.PostableAlert][]string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *MockAlertmanager_TestAlert_Call) Return(err error) *MockAlertmanager_TestAlert_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockAlertmanager_TestAlert_Call) RunAndReturn(run func(ctx context.Context, orgID string, ruleID string, receiversMap map[*alertmanagertypes.PostableAlert][]string) error) *MockAlertmanager_TestAlert_Call {
	_c.Call.Return(run)
	return _c
}

// TestReceiver provides a mock function for the type MockAlertmanager
func (_mock *MockAlertmanager) TestReceiver(context1 context.Context, s string, v alertmanagertypes.Receiver) error {
	ret := _mock.Called(context1, s, v)

	if len(ret) == 0 {
		panic("no return value specified for TestReceiver")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, alertmanagertypes.Receiver) error); ok {
		r0 = returnFunc(context1, s, v)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockAlertmanager_TestReceiver_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TestReceiver'
type MockAlertmanager_TestReceiver_Call struct {
	*mock.Call
}

// TestReceiver is a helper method to define mock.On call
//   - context1 context.Context
//   - s string
//   - v alertmanagertypes.Receiver
func (_e *MockAlertmanager_Expecter) TestReceiver(context1 interface{}, s interface{}, v interface{}) *MockAlertmanager_TestReceiver_Call {
	return &MockAlertmanager_TestReceiver_Call{Call: _e.mock.On("TestReceiver", context1, s, v)}
}

func (_c *MockAlertmanager_TestReceiver_Call) Run(run func(context1 context.Context, s string, v alertmanagertypes.Receiver)) *MockAlertmanager_TestReceiver_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 alertmanagertypes.Receiver
		if args[2] != nil {
			arg2 = args[2].(alertmanagertypes.Receiver)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAlertmanager_TestReceiver_Call) Return(err error) *MockAlertmanager_TestReceiver_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockAlertmanager_TestReceiver_Call) RunAndReturn(run func(context1 context.Context, s string, v alertmanagertypes.Receiver) error) *MockAlertmanager_TestReceiver_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateAllRoutePoliciesByRuleId provides a mock function for the type MockAlertmanager
func (_mock *MockAlertmanager) UpdateAllRoutePoliciesByRuleId(ctx context.Context, ruleId string, routes []*alertmanagertypes.PostableRoutePolicy) error {
	ret := _mock.Called(ctx, ruleId, routes)

	if len(ret) == 0 {
		panic("no return value specified for UpdateAllRoutePoliciesByRuleId")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, []*alertmanagertypes.PostableRoutePolicy) error); ok {
		r0 = returnFunc(ctx, ruleId, routes)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockAlertmanager_UpdateAllRoutePoliciesByRuleId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateAllRoutePoliciesByRuleId'
type MockAlertmanager_UpdateAllRoutePoliciesByRuleId_Call struct {
	*mock.Call
}

// UpdateAllRoutePoliciesByRuleId is a helper method to define mock.On call
//   - ctx context.Context
//   - ruleId string
//   - routes []*alertmanagertypes.PostableRoutePolicy
func (_e *MockAlertmanager_Expecter) UpdateAllRoutePoliciesByRuleId(ctx interface{}, ruleId interface{}, routes interface{}) *MockAlertmanager_UpdateAllRoutePoliciesByRuleId_Call {
	return &MockAlertmanager_UpdateAllRoutePoliciesByRuleId_Call{Call: _e.mock.On("UpdateAllRoutePoliciesByRuleId", ctx, ruleId, routes)}
}

func (_c *MockAlertmanager_UpdateAllRoutePoliciesByRuleId_Call) Run(run func(ctx context.Context, ruleId string, routes []*alertmanagertypes.PostableRoutePolicy)) *MockAlertmanager_UpdateAllRoutePoliciesByRuleId_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 []*alertmanagertypes.PostableRoutePolicy
		if args[2] != nil {
			arg2 = args[2].([]*alertmanagertypes.PostableRoutePolicy)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAlertmanager_UpdateAllRoutePoliciesByRuleId_Call) Return(err error) *MockAlertmanager_UpdateAllRoutePoliciesByRuleId_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockAlertmanager_UpdateAllRoutePoliciesByRuleId_Call) RunAndReturn(run func(ctx context.Context, ruleId string, routes []*alertmanagertypes.PostableRoutePolicy) error) *MockAlertmanager_UpdateAllRoutePoliciesByRuleId_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateChannelByReceiverAndID provides a mock function for the type MockAlertmanager
func (_mock *MockAlertmanager) UpdateChannelByReceiverAndID(context1 context.Context, s string, v alertmanagertypes.Receiver, uUID valuer.UUID) error {
	ret := _mock.Called(context1, s, v, uUID)

	if len(ret) == 0 {
		panic("no return value specified for UpdateChannelByReceiverAndID")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, alertmanagertypes.Receiver, valuer.UUID) error); ok {
		r0 = returnFunc(context1, s, v, uUID)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockAlertmanager_UpdateChannelByReceiverAndID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateChannelByReceiverAndID'
type MockAlertmanager_UpdateChannelByReceiverAndID_Call struct {
	*mock.Call
}

// UpdateChannelByReceiverAndID is a helper method to define mock.On call
//   - context1 context.Context
//   - s string
//   - v alertmanagertypes.Receiver
//   - uUID valuer.UUID
func (_e *MockAlertmanager_Expecter) UpdateChannelByReceiverAndID(context1 interface{}, s interface{}, v interface{}, uUID interface{}) *MockAlertmanager_UpdateChannelByReceiverAndID_Call {
	return &MockAlertmanager_UpdateChannelByReceiverAndID_Call{Call: _e.mock.On("UpdateChannelByReceiverAndID", context1, s, v, uUID)}
}

func (_c *MockAlertmanager_UpdateChannelByReceiverAndID_Call) Run(run func(context1 context.Context, s string, v alertmanagertypes.Receiver, uUID valuer.UUID)) *MockAlertmanager_UpdateChannelByReceiverAndID_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 alertmanagertypes.Receiver
		if args[2] != nil {
			arg2 = args[2].(alertmanagertypes.Receiver)
		}
		var arg3 valuer.UUID
		if args[3] != nil {
			arg3 = args[3].(valuer.UUID)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *MockAlertmanager_UpdateChannelByReceiverAndID_Call) Return(err error) *MockAlertmanager_UpdateChannelByReceiverAndID_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockAlertmanager_UpdateChannelByReceiverAndID_Call) RunAndReturn(run func(context1 context.Context, s string, v alertmanagertypes.Receiver, uUID valuer.UUID) error) *MockAlertmanager_UpdateChannelByReceiverAndID_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateRoutePolicyByID provides a mock function for the type MockAlertmanager
func (_mock *MockAlertmanager) UpdateRoutePolicyByID(ctx context.Context, routeID string, route *alertmanagertypes.PostableRoutePolicy) (*alertmanagertypes.GettableRoutePolicy, error) {
	ret := _mock.Called(ctx, routeID, route)

	if len(ret) == 0 {
		panic("no return value specified for UpdateRoutePolicyByID")
	}

	var r0 *alertmanagertypes.GettableRoutePolicy
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *alertmanagertypes.PostableRoutePolicy) (*alertmanagertypes.GettableRoutePolicy, error)); ok {
		return returnFunc(ctx, routeID, route)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *alertmanagertypes.PostableRoutePolicy) *alertmanagertypes.GettableRoutePolicy); ok {
		r0 = returnFunc(ctx, routeID, route)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*alertmanagertypes.GettableRoutePolicy)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, *alertmanagertypes.PostableRoutePolicy) error); ok {
		r1 = returnFunc(ctx, routeID, route)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockAlertmanager_UpdateRoutePolicyByID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateRoutePolicyByID'
type MockAlertmanager_UpdateRoutePolicyByID_Call struct {
	*mock.Call
}

// UpdateRoutePolicyByID is a helper method to define mock.On call
//   - ctx context.Context
//   - routeID string
//   - route *alertmanagertypes.PostableRoutePolicy
func (_e *MockAlertmanager_Expecter) UpdateRoutePolicyByID(ctx interface{}, routeID interface{}, route interface{}) *MockAlertmanager_UpdateRoutePolicyByID_Call {
	return &MockAlertmanager_UpdateRoutePolicyByID_Call{Call: _e.mock.On("UpdateRoutePolicyByID", ctx, routeID, route)}
}

func (_c *MockAlertmanager_UpdateRoutePolicyByID_Call) Run(run func(ctx context.Context, routeID string, route *alertmanagertypes.PostableRoutePolicy)) *MockAlertmanager_UpdateRoutePolicyByID_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 *alertmanagertypes.PostableRoutePolicy
		if args[2] != nil {
			arg2 = args[2].(*alertmanagertypes.PostableRoutePolicy)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAlertmanager_UpdateRoutePolicyByID_Call) Return(gettableRoutePolicy *alertmanagertypes.GettableRoutePolicy, err error) *MockAlertmanager_UpdateRoutePolicyByID_Call {
	_c.Call.Return(gettableRoutePolicy, err)
	return _c
}

func (_c *MockAlertmanager_UpdateRoutePolicyByID_Call) RunAndReturn(run func(ctx context.Context, routeID string, route *alertmanagertypes.PostableRoutePolicy) (*alertmanagertypes.GettableRoutePolicy, error)) *MockAlertmanager_UpdateRoutePolicyByID_Call {
	_c.Call.Return(run)
	return _c
}
