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

package mocks

import (
	"context"

	"github.com/bnema/gordon/internal/domain"
	mock "github.com/stretchr/testify/mock"
)

// NewMockConfigService creates a new instance of MockConfigService. 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 NewMockConfigService(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockConfigService {
	mock := &MockConfigService{}
	mock.Mock.Test(t)

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

	return mock
}

// MockConfigService is an autogenerated mock type for the ConfigService type
type MockConfigService struct {
	mock.Mock
}

type MockConfigService_Expecter struct {
	mock *mock.Mock
}

func (_m *MockConfigService) EXPECT() *MockConfigService_Expecter {
	return &MockConfigService_Expecter{mock: &_m.Mock}
}

// AddAttachment provides a mock function for the type MockConfigService
func (_mock *MockConfigService) AddAttachment(ctx context.Context, domainOrGroup string, image string) error {
	ret := _mock.Called(ctx, domainOrGroup, image)

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

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

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

// AddAttachment is a helper method to define mock.On call
//   - ctx context.Context
//   - domainOrGroup string
//   - image string
func (_e *MockConfigService_Expecter) AddAttachment(ctx any, domainOrGroup any, image any) *MockConfigService_AddAttachment_Call {
	return &MockConfigService_AddAttachment_Call{Call: _e.mock.On("AddAttachment", ctx, domainOrGroup, image)}
}

func (_c *MockConfigService_AddAttachment_Call) Run(run func(ctx context.Context, domainOrGroup string, image string)) *MockConfigService_AddAttachment_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)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

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

func (_c *MockConfigService_AddAttachment_Call) RunAndReturn(run func(ctx context.Context, domainOrGroup string, image string) error) *MockConfigService_AddAttachment_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

// AddAutoRouteAllowedDomain is a helper method to define mock.On call
//   - ctx context.Context
//   - pattern string
func (_e *MockConfigService_Expecter) AddAutoRouteAllowedDomain(ctx any, pattern any) *MockConfigService_AddAutoRouteAllowedDomain_Call {
	return &MockConfigService_AddAutoRouteAllowedDomain_Call{Call: _e.mock.On("AddAutoRouteAllowedDomain", ctx, pattern)}
}

func (_c *MockConfigService_AddAutoRouteAllowedDomain_Call) Run(run func(ctx context.Context, pattern string)) *MockConfigService_AddAutoRouteAllowedDomain_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 *MockConfigService_AddAutoRouteAllowedDomain_Call) Return(err error) *MockConfigService_AddAutoRouteAllowedDomain_Call {
	_c.Call.Return(err)
	return _c
}

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

// AddRoute provides a mock function for the type MockConfigService
func (_mock *MockConfigService) AddRoute(ctx context.Context, route domain.Route) error {
	ret := _mock.Called(ctx, route)

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

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

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

// AddRoute is a helper method to define mock.On call
//   - ctx context.Context
//   - route domain.Route
func (_e *MockConfigService_Expecter) AddRoute(ctx any, route any) *MockConfigService_AddRoute_Call {
	return &MockConfigService_AddRoute_Call{Call: _e.mock.On("AddRoute", ctx, route)}
}

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

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

func (_c *MockConfigService_AddRoute_Call) RunAndReturn(run func(ctx context.Context, route domain.Route) error) *MockConfigService_AddRoute_Call {
	_c.Call.Return(run)
	return _c
}

// FindAttachmentTargetsByImage provides a mock function for the type MockConfigService
func (_mock *MockConfigService) FindAttachmentTargetsByImage(ctx context.Context, imageName string) []string {
	ret := _mock.Called(ctx, imageName)

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

	var r0 []string
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []string); ok {
		r0 = returnFunc(ctx, imageName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]string)
		}
	}
	return r0
}

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

// FindAttachmentTargetsByImage is a helper method to define mock.On call
//   - ctx context.Context
//   - imageName string
func (_e *MockConfigService_Expecter) FindAttachmentTargetsByImage(ctx any, imageName any) *MockConfigService_FindAttachmentTargetsByImage_Call {
	return &MockConfigService_FindAttachmentTargetsByImage_Call{Call: _e.mock.On("FindAttachmentTargetsByImage", ctx, imageName)}
}

func (_c *MockConfigService_FindAttachmentTargetsByImage_Call) Run(run func(ctx context.Context, imageName string)) *MockConfigService_FindAttachmentTargetsByImage_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 *MockConfigService_FindAttachmentTargetsByImage_Call) Return(strings []string) *MockConfigService_FindAttachmentTargetsByImage_Call {
	_c.Call.Return(strings)
	return _c
}

func (_c *MockConfigService_FindAttachmentTargetsByImage_Call) RunAndReturn(run func(ctx context.Context, imageName string) []string) *MockConfigService_FindAttachmentTargetsByImage_Call {
	_c.Call.Return(run)
	return _c
}

// FindRoutesByImage provides a mock function for the type MockConfigService
func (_mock *MockConfigService) FindRoutesByImage(ctx context.Context, imageName string) []domain.Route {
	ret := _mock.Called(ctx, imageName)

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

	var r0 []domain.Route
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []domain.Route); ok {
		r0 = returnFunc(ctx, imageName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]domain.Route)
		}
	}
	return r0
}

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

// FindRoutesByImage is a helper method to define mock.On call
//   - ctx context.Context
//   - imageName string
func (_e *MockConfigService_Expecter) FindRoutesByImage(ctx any, imageName any) *MockConfigService_FindRoutesByImage_Call {
	return &MockConfigService_FindRoutesByImage_Call{Call: _e.mock.On("FindRoutesByImage", ctx, imageName)}
}

func (_c *MockConfigService_FindRoutesByImage_Call) Run(run func(ctx context.Context, imageName string)) *MockConfigService_FindRoutesByImage_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 *MockConfigService_FindRoutesByImage_Call) Return(routes []domain.Route) *MockConfigService_FindRoutesByImage_Call {
	_c.Call.Return(routes)
	return _c
}

func (_c *MockConfigService_FindRoutesByImage_Call) RunAndReturn(run func(ctx context.Context, imageName string) []domain.Route) *MockConfigService_FindRoutesByImage_Call {
	_c.Call.Return(run)
	return _c
}

// GetAllAttachments provides a mock function for the type MockConfigService
func (_mock *MockConfigService) GetAllAttachments(ctx context.Context) map[string][]string {
	ret := _mock.Called(ctx)

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

	var r0 map[string][]string
	if returnFunc, ok := ret.Get(0).(func(context.Context) map[string][]string); ok {
		r0 = returnFunc(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[string][]string)
		}
	}
	return r0
}

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

// GetAllAttachments is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockConfigService_Expecter) GetAllAttachments(ctx any) *MockConfigService_GetAllAttachments_Call {
	return &MockConfigService_GetAllAttachments_Call{Call: _e.mock.On("GetAllAttachments", ctx)}
}

func (_c *MockConfigService_GetAllAttachments_Call) Run(run func(ctx context.Context)) *MockConfigService_GetAllAttachments_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 *MockConfigService_GetAllAttachments_Call) Return(stringToStrings map[string][]string) *MockConfigService_GetAllAttachments_Call {
	_c.Call.Return(stringToStrings)
	return _c
}

func (_c *MockConfigService_GetAllAttachments_Call) RunAndReturn(run func(ctx context.Context) map[string][]string) *MockConfigService_GetAllAttachments_Call {
	_c.Call.Return(run)
	return _c
}

// GetAllowedDomains provides a mock function for the type MockConfigService
func (_mock *MockConfigService) GetAllowedDomains() []string {
	ret := _mock.Called()

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

	var r0 []string
	if returnFunc, ok := ret.Get(0).(func() []string); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]string)
		}
	}
	return r0
}

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

// GetAllowedDomains is a helper method to define mock.On call
func (_e *MockConfigService_Expecter) GetAllowedDomains() *MockConfigService_GetAllowedDomains_Call {
	return &MockConfigService_GetAllowedDomains_Call{Call: _e.mock.On("GetAllowedDomains")}
}

func (_c *MockConfigService_GetAllowedDomains_Call) Run(run func()) *MockConfigService_GetAllowedDomains_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockConfigService_GetAllowedDomains_Call) Return(strings []string) *MockConfigService_GetAllowedDomains_Call {
	_c.Call.Return(strings)
	return _c
}

func (_c *MockConfigService_GetAllowedDomains_Call) RunAndReturn(run func() []string) *MockConfigService_GetAllowedDomains_Call {
	_c.Call.Return(run)
	return _c
}

// GetAttachmentsFor provides a mock function for the type MockConfigService
func (_mock *MockConfigService) GetAttachmentsFor(ctx context.Context, domainOrGroup string) ([]string, error) {
	ret := _mock.Called(ctx, domainOrGroup)

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

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

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

// GetAttachmentsFor is a helper method to define mock.On call
//   - ctx context.Context
//   - domainOrGroup string
func (_e *MockConfigService_Expecter) GetAttachmentsFor(ctx any, domainOrGroup any) *MockConfigService_GetAttachmentsFor_Call {
	return &MockConfigService_GetAttachmentsFor_Call{Call: _e.mock.On("GetAttachmentsFor", ctx, domainOrGroup)}
}

func (_c *MockConfigService_GetAttachmentsFor_Call) Run(run func(ctx context.Context, domainOrGroup string)) *MockConfigService_GetAttachmentsFor_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 *MockConfigService_GetAttachmentsFor_Call) Return(strings []string, err error) *MockConfigService_GetAttachmentsFor_Call {
	_c.Call.Return(strings, err)
	return _c
}

func (_c *MockConfigService_GetAttachmentsFor_Call) RunAndReturn(run func(ctx context.Context, domainOrGroup string) ([]string, error)) *MockConfigService_GetAttachmentsFor_Call {
	_c.Call.Return(run)
	return _c
}

// GetAutoRouteAllowedDomains provides a mock function for the type MockConfigService
func (_mock *MockConfigService) GetAutoRouteAllowedDomains(ctx context.Context) ([]string, error) {
	ret := _mock.Called(ctx)

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

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

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

// GetAutoRouteAllowedDomains is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockConfigService_Expecter) GetAutoRouteAllowedDomains(ctx any) *MockConfigService_GetAutoRouteAllowedDomains_Call {
	return &MockConfigService_GetAutoRouteAllowedDomains_Call{Call: _e.mock.On("GetAutoRouteAllowedDomains", ctx)}
}

func (_c *MockConfigService_GetAutoRouteAllowedDomains_Call) Run(run func(ctx context.Context)) *MockConfigService_GetAutoRouteAllowedDomains_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 *MockConfigService_GetAutoRouteAllowedDomains_Call) Return(strings []string, err error) *MockConfigService_GetAutoRouteAllowedDomains_Call {
	_c.Call.Return(strings, err)
	return _c
}

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

// GetDataDir provides a mock function for the type MockConfigService
func (_mock *MockConfigService) GetDataDir() string {
	ret := _mock.Called()

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

	var r0 string
	if returnFunc, ok := ret.Get(0).(func() string); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(string)
	}
	return r0
}

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

// GetDataDir is a helper method to define mock.On call
func (_e *MockConfigService_Expecter) GetDataDir() *MockConfigService_GetDataDir_Call {
	return &MockConfigService_GetDataDir_Call{Call: _e.mock.On("GetDataDir")}
}

func (_c *MockConfigService_GetDataDir_Call) Run(run func()) *MockConfigService_GetDataDir_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockConfigService_GetDataDir_Call) Return(s string) *MockConfigService_GetDataDir_Call {
	_c.Call.Return(s)
	return _c
}

func (_c *MockConfigService_GetDataDir_Call) RunAndReturn(run func() string) *MockConfigService_GetDataDir_Call {
	_c.Call.Return(run)
	return _c
}

// GetExternalRoutes provides a mock function for the type MockConfigService
func (_mock *MockConfigService) GetExternalRoutes() map[string]string {
	ret := _mock.Called()

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

	var r0 map[string]string
	if returnFunc, ok := ret.Get(0).(func() map[string]string); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[string]string)
		}
	}
	return r0
}

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

// GetExternalRoutes is a helper method to define mock.On call
func (_e *MockConfigService_Expecter) GetExternalRoutes() *MockConfigService_GetExternalRoutes_Call {
	return &MockConfigService_GetExternalRoutes_Call{Call: _e.mock.On("GetExternalRoutes")}
}

func (_c *MockConfigService_GetExternalRoutes_Call) Run(run func()) *MockConfigService_GetExternalRoutes_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockConfigService_GetExternalRoutes_Call) Return(stringToString map[string]string) *MockConfigService_GetExternalRoutes_Call {
	_c.Call.Return(stringToString)
	return _c
}

func (_c *MockConfigService_GetExternalRoutes_Call) RunAndReturn(run func() map[string]string) *MockConfigService_GetExternalRoutes_Call {
	_c.Call.Return(run)
	return _c
}

// GetNetworkPrefix provides a mock function for the type MockConfigService
func (_mock *MockConfigService) GetNetworkPrefix() string {
	ret := _mock.Called()

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

	var r0 string
	if returnFunc, ok := ret.Get(0).(func() string); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(string)
	}
	return r0
}

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

// GetNetworkPrefix is a helper method to define mock.On call
func (_e *MockConfigService_Expecter) GetNetworkPrefix() *MockConfigService_GetNetworkPrefix_Call {
	return &MockConfigService_GetNetworkPrefix_Call{Call: _e.mock.On("GetNetworkPrefix")}
}

func (_c *MockConfigService_GetNetworkPrefix_Call) Run(run func()) *MockConfigService_GetNetworkPrefix_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockConfigService_GetNetworkPrefix_Call) Return(s string) *MockConfigService_GetNetworkPrefix_Call {
	_c.Call.Return(s)
	return _c
}

func (_c *MockConfigService_GetNetworkPrefix_Call) RunAndReturn(run func() string) *MockConfigService_GetNetworkPrefix_Call {
	_c.Call.Return(run)
	return _c
}

// GetPreviewConfig provides a mock function for the type MockConfigService
func (_mock *MockConfigService) GetPreviewConfig() domain.PreviewConfig {
	ret := _mock.Called()

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

	var r0 domain.PreviewConfig
	if returnFunc, ok := ret.Get(0).(func() domain.PreviewConfig); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(domain.PreviewConfig)
	}
	return r0
}

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

// GetPreviewConfig is a helper method to define mock.On call
func (_e *MockConfigService_Expecter) GetPreviewConfig() *MockConfigService_GetPreviewConfig_Call {
	return &MockConfigService_GetPreviewConfig_Call{Call: _e.mock.On("GetPreviewConfig")}
}

func (_c *MockConfigService_GetPreviewConfig_Call) Run(run func()) *MockConfigService_GetPreviewConfig_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockConfigService_GetPreviewConfig_Call) Return(previewConfig domain.PreviewConfig) *MockConfigService_GetPreviewConfig_Call {
	_c.Call.Return(previewConfig)
	return _c
}

func (_c *MockConfigService_GetPreviewConfig_Call) RunAndReturn(run func() domain.PreviewConfig) *MockConfigService_GetPreviewConfig_Call {
	_c.Call.Return(run)
	return _c
}

// GetPreviewTagPatterns provides a mock function for the type MockConfigService
func (_mock *MockConfigService) GetPreviewTagPatterns() []string {
	ret := _mock.Called()

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

	var r0 []string
	if returnFunc, ok := ret.Get(0).(func() []string); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]string)
		}
	}
	return r0
}

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

// GetPreviewTagPatterns is a helper method to define mock.On call
func (_e *MockConfigService_Expecter) GetPreviewTagPatterns() *MockConfigService_GetPreviewTagPatterns_Call {
	return &MockConfigService_GetPreviewTagPatterns_Call{Call: _e.mock.On("GetPreviewTagPatterns")}
}

func (_c *MockConfigService_GetPreviewTagPatterns_Call) Run(run func()) *MockConfigService_GetPreviewTagPatterns_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockConfigService_GetPreviewTagPatterns_Call) Return(strings []string) *MockConfigService_GetPreviewTagPatterns_Call {
	_c.Call.Return(strings)
	return _c
}

func (_c *MockConfigService_GetPreviewTagPatterns_Call) RunAndReturn(run func() []string) *MockConfigService_GetPreviewTagPatterns_Call {
	_c.Call.Return(run)
	return _c
}

// GetRegistryDomain provides a mock function for the type MockConfigService
func (_mock *MockConfigService) GetRegistryDomain() string {
	ret := _mock.Called()

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

	var r0 string
	if returnFunc, ok := ret.Get(0).(func() string); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(string)
	}
	return r0
}

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

// GetRegistryDomain is a helper method to define mock.On call
func (_e *MockConfigService_Expecter) GetRegistryDomain() *MockConfigService_GetRegistryDomain_Call {
	return &MockConfigService_GetRegistryDomain_Call{Call: _e.mock.On("GetRegistryDomain")}
}

func (_c *MockConfigService_GetRegistryDomain_Call) Run(run func()) *MockConfigService_GetRegistryDomain_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockConfigService_GetRegistryDomain_Call) Return(s string) *MockConfigService_GetRegistryDomain_Call {
	_c.Call.Return(s)
	return _c
}

func (_c *MockConfigService_GetRegistryDomain_Call) RunAndReturn(run func() string) *MockConfigService_GetRegistryDomain_Call {
	_c.Call.Return(run)
	return _c
}

// GetRegistryPort provides a mock function for the type MockConfigService
func (_mock *MockConfigService) GetRegistryPort() int {
	ret := _mock.Called()

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

	var r0 int
	if returnFunc, ok := ret.Get(0).(func() int); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(int)
	}
	return r0
}

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

// GetRegistryPort is a helper method to define mock.On call
func (_e *MockConfigService_Expecter) GetRegistryPort() *MockConfigService_GetRegistryPort_Call {
	return &MockConfigService_GetRegistryPort_Call{Call: _e.mock.On("GetRegistryPort")}
}

func (_c *MockConfigService_GetRegistryPort_Call) Run(run func()) *MockConfigService_GetRegistryPort_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockConfigService_GetRegistryPort_Call) Return(n int) *MockConfigService_GetRegistryPort_Call {
	_c.Call.Return(n)
	return _c
}

func (_c *MockConfigService_GetRegistryPort_Call) RunAndReturn(run func() int) *MockConfigService_GetRegistryPort_Call {
	_c.Call.Return(run)
	return _c
}

// GetRoute provides a mock function for the type MockConfigService
func (_mock *MockConfigService) GetRoute(ctx context.Context, domain1 string) (*domain.Route, error) {
	ret := _mock.Called(ctx, domain1)

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

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

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

// GetRoute is a helper method to define mock.On call
//   - ctx context.Context
//   - domain1 string
func (_e *MockConfigService_Expecter) GetRoute(ctx any, domain1 any) *MockConfigService_GetRoute_Call {
	return &MockConfigService_GetRoute_Call{Call: _e.mock.On("GetRoute", ctx, domain1)}
}

func (_c *MockConfigService_GetRoute_Call) Run(run func(ctx context.Context, domain1 string)) *MockConfigService_GetRoute_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 *MockConfigService_GetRoute_Call) Return(route *domain.Route, err error) *MockConfigService_GetRoute_Call {
	_c.Call.Return(route, err)
	return _c
}

func (_c *MockConfigService_GetRoute_Call) RunAndReturn(run func(ctx context.Context, domain1 string) (*domain.Route, error)) *MockConfigService_GetRoute_Call {
	_c.Call.Return(run)
	return _c
}

// GetRoutes provides a mock function for the type MockConfigService
func (_mock *MockConfigService) GetRoutes(ctx context.Context) []domain.Route {
	ret := _mock.Called(ctx)

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

	var r0 []domain.Route
	if returnFunc, ok := ret.Get(0).(func(context.Context) []domain.Route); ok {
		r0 = returnFunc(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]domain.Route)
		}
	}
	return r0
}

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

// GetRoutes is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockConfigService_Expecter) GetRoutes(ctx any) *MockConfigService_GetRoutes_Call {
	return &MockConfigService_GetRoutes_Call{Call: _e.mock.On("GetRoutes", ctx)}
}

func (_c *MockConfigService_GetRoutes_Call) Run(run func(ctx context.Context)) *MockConfigService_GetRoutes_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 *MockConfigService_GetRoutes_Call) Return(routes []domain.Route) *MockConfigService_GetRoutes_Call {
	_c.Call.Return(routes)
	return _c
}

func (_c *MockConfigService_GetRoutes_Call) RunAndReturn(run func(ctx context.Context) []domain.Route) *MockConfigService_GetRoutes_Call {
	_c.Call.Return(run)
	return _c
}

// GetServerPort provides a mock function for the type MockConfigService
func (_mock *MockConfigService) GetServerPort() int {
	ret := _mock.Called()

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

	var r0 int
	if returnFunc, ok := ret.Get(0).(func() int); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(int)
	}
	return r0
}

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

// GetServerPort is a helper method to define mock.On call
func (_e *MockConfigService_Expecter) GetServerPort() *MockConfigService_GetServerPort_Call {
	return &MockConfigService_GetServerPort_Call{Call: _e.mock.On("GetServerPort")}
}

func (_c *MockConfigService_GetServerPort_Call) Run(run func()) *MockConfigService_GetServerPort_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockConfigService_GetServerPort_Call) Return(n int) *MockConfigService_GetServerPort_Call {
	_c.Call.Return(n)
	return _c
}

func (_c *MockConfigService_GetServerPort_Call) RunAndReturn(run func() int) *MockConfigService_GetServerPort_Call {
	_c.Call.Return(run)
	return _c
}

// IsAutoEnabled provides a mock function for the type MockConfigService
func (_mock *MockConfigService) IsAutoEnabled() bool {
	ret := _mock.Called()

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

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

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

// IsAutoEnabled is a helper method to define mock.On call
func (_e *MockConfigService_Expecter) IsAutoEnabled() *MockConfigService_IsAutoEnabled_Call {
	return &MockConfigService_IsAutoEnabled_Call{Call: _e.mock.On("IsAutoEnabled")}
}

func (_c *MockConfigService_IsAutoEnabled_Call) Run(run func()) *MockConfigService_IsAutoEnabled_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockConfigService_IsAutoEnabled_Call) Return(b bool) *MockConfigService_IsAutoEnabled_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockConfigService_IsAutoEnabled_Call) RunAndReturn(run func() bool) *MockConfigService_IsAutoEnabled_Call {
	_c.Call.Return(run)
	return _c
}

// IsAutoRouteEnabled provides a mock function for the type MockConfigService
func (_mock *MockConfigService) IsAutoRouteEnabled() bool {
	ret := _mock.Called()

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

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

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

// IsAutoRouteEnabled is a helper method to define mock.On call
func (_e *MockConfigService_Expecter) IsAutoRouteEnabled() *MockConfigService_IsAutoRouteEnabled_Call {
	return &MockConfigService_IsAutoRouteEnabled_Call{Call: _e.mock.On("IsAutoRouteEnabled")}
}

func (_c *MockConfigService_IsAutoRouteEnabled_Call) Run(run func()) *MockConfigService_IsAutoRouteEnabled_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockConfigService_IsAutoRouteEnabled_Call) Return(b bool) *MockConfigService_IsAutoRouteEnabled_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockConfigService_IsAutoRouteEnabled_Call) RunAndReturn(run func() bool) *MockConfigService_IsAutoRouteEnabled_Call {
	_c.Call.Return(run)
	return _c
}

// IsNetworkIsolationEnabled provides a mock function for the type MockConfigService
func (_mock *MockConfigService) IsNetworkIsolationEnabled() bool {
	ret := _mock.Called()

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

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

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

// IsNetworkIsolationEnabled is a helper method to define mock.On call
func (_e *MockConfigService_Expecter) IsNetworkIsolationEnabled() *MockConfigService_IsNetworkIsolationEnabled_Call {
	return &MockConfigService_IsNetworkIsolationEnabled_Call{Call: _e.mock.On("IsNetworkIsolationEnabled")}
}

func (_c *MockConfigService_IsNetworkIsolationEnabled_Call) Run(run func()) *MockConfigService_IsNetworkIsolationEnabled_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockConfigService_IsNetworkIsolationEnabled_Call) Return(b bool) *MockConfigService_IsNetworkIsolationEnabled_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockConfigService_IsNetworkIsolationEnabled_Call) RunAndReturn(run func() bool) *MockConfigService_IsNetworkIsolationEnabled_Call {
	_c.Call.Return(run)
	return _c
}

// IsPreviewEnabled provides a mock function for the type MockConfigService
func (_mock *MockConfigService) IsPreviewEnabled() bool {
	ret := _mock.Called()

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

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

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

// IsPreviewEnabled is a helper method to define mock.On call
func (_e *MockConfigService_Expecter) IsPreviewEnabled() *MockConfigService_IsPreviewEnabled_Call {
	return &MockConfigService_IsPreviewEnabled_Call{Call: _e.mock.On("IsPreviewEnabled")}
}

func (_c *MockConfigService_IsPreviewEnabled_Call) Run(run func()) *MockConfigService_IsPreviewEnabled_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockConfigService_IsPreviewEnabled_Call) Return(b bool) *MockConfigService_IsPreviewEnabled_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockConfigService_IsPreviewEnabled_Call) RunAndReturn(run func() bool) *MockConfigService_IsPreviewEnabled_Call {
	_c.Call.Return(run)
	return _c
}

// Load provides a mock function for the type MockConfigService
func (_mock *MockConfigService) Load(ctx context.Context) error {
	ret := _mock.Called(ctx)

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

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

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

// Load is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockConfigService_Expecter) Load(ctx any) *MockConfigService_Load_Call {
	return &MockConfigService_Load_Call{Call: _e.mock.On("Load", ctx)}
}

func (_c *MockConfigService_Load_Call) Run(run func(ctx context.Context)) *MockConfigService_Load_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 *MockConfigService_Load_Call) Return(err error) *MockConfigService_Load_Call {
	_c.Call.Return(err)
	return _c
}

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

// Reload provides a mock function for the type MockConfigService
func (_mock *MockConfigService) Reload(ctx context.Context) error {
	ret := _mock.Called(ctx)

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

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

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

// Reload is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockConfigService_Expecter) Reload(ctx any) *MockConfigService_Reload_Call {
	return &MockConfigService_Reload_Call{Call: _e.mock.On("Reload", ctx)}
}

func (_c *MockConfigService_Reload_Call) Run(run func(ctx context.Context)) *MockConfigService_Reload_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 *MockConfigService_Reload_Call) Return(err error) *MockConfigService_Reload_Call {
	_c.Call.Return(err)
	return _c
}

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

// RemoveAttachment provides a mock function for the type MockConfigService
func (_mock *MockConfigService) RemoveAttachment(ctx context.Context, domainOrGroup string, image string) error {
	ret := _mock.Called(ctx, domainOrGroup, image)

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

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

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

// RemoveAttachment is a helper method to define mock.On call
//   - ctx context.Context
//   - domainOrGroup string
//   - image string
func (_e *MockConfigService_Expecter) RemoveAttachment(ctx any, domainOrGroup any, image any) *MockConfigService_RemoveAttachment_Call {
	return &MockConfigService_RemoveAttachment_Call{Call: _e.mock.On("RemoveAttachment", ctx, domainOrGroup, image)}
}

func (_c *MockConfigService_RemoveAttachment_Call) Run(run func(ctx context.Context, domainOrGroup string, image string)) *MockConfigService_RemoveAttachment_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)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

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

func (_c *MockConfigService_RemoveAttachment_Call) RunAndReturn(run func(ctx context.Context, domainOrGroup string, image string) error) *MockConfigService_RemoveAttachment_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

// RemoveAutoRouteAllowedDomain is a helper method to define mock.On call
//   - ctx context.Context
//   - pattern string
func (_e *MockConfigService_Expecter) RemoveAutoRouteAllowedDomain(ctx any, pattern any) *MockConfigService_RemoveAutoRouteAllowedDomain_Call {
	return &MockConfigService_RemoveAutoRouteAllowedDomain_Call{Call: _e.mock.On("RemoveAutoRouteAllowedDomain", ctx, pattern)}
}

func (_c *MockConfigService_RemoveAutoRouteAllowedDomain_Call) Run(run func(ctx context.Context, pattern string)) *MockConfigService_RemoveAutoRouteAllowedDomain_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 *MockConfigService_RemoveAutoRouteAllowedDomain_Call) Return(err error) *MockConfigService_RemoveAutoRouteAllowedDomain_Call {
	_c.Call.Return(err)
	return _c
}

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

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

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

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

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

// RemoveRoute is a helper method to define mock.On call
//   - ctx context.Context
//   - domain1 string
func (_e *MockConfigService_Expecter) RemoveRoute(ctx any, domain1 any) *MockConfigService_RemoveRoute_Call {
	return &MockConfigService_RemoveRoute_Call{Call: _e.mock.On("RemoveRoute", ctx, domain1)}
}

func (_c *MockConfigService_RemoveRoute_Call) Run(run func(ctx context.Context, domain1 string)) *MockConfigService_RemoveRoute_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 *MockConfigService_RemoveRoute_Call) Return(err error) *MockConfigService_RemoveRoute_Call {
	_c.Call.Return(err)
	return _c
}

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

// Save provides a mock function for the type MockConfigService
func (_mock *MockConfigService) Save(ctx context.Context) error {
	ret := _mock.Called(ctx)

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

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

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

// Save is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockConfigService_Expecter) Save(ctx any) *MockConfigService_Save_Call {
	return &MockConfigService_Save_Call{Call: _e.mock.On("Save", ctx)}
}

func (_c *MockConfigService_Save_Call) Run(run func(ctx context.Context)) *MockConfigService_Save_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 *MockConfigService_Save_Call) Return(err error) *MockConfigService_Save_Call {
	_c.Call.Return(err)
	return _c
}

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

// UpdateRoute provides a mock function for the type MockConfigService
func (_mock *MockConfigService) UpdateRoute(ctx context.Context, route domain.Route) error {
	ret := _mock.Called(ctx, route)

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

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

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

// UpdateRoute is a helper method to define mock.On call
//   - ctx context.Context
//   - route domain.Route
func (_e *MockConfigService_Expecter) UpdateRoute(ctx any, route any) *MockConfigService_UpdateRoute_Call {
	return &MockConfigService_UpdateRoute_Call{Call: _e.mock.On("UpdateRoute", ctx, route)}
}

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

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

func (_c *MockConfigService_UpdateRoute_Call) RunAndReturn(run func(ctx context.Context, route domain.Route) error) *MockConfigService_UpdateRoute_Call {
	_c.Call.Return(run)
	return _c
}

// Watch provides a mock function for the type MockConfigService
func (_mock *MockConfigService) Watch(ctx context.Context, onChange func()) error {
	ret := _mock.Called(ctx, onChange)

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

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

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

// Watch is a helper method to define mock.On call
//   - ctx context.Context
//   - onChange func()
func (_e *MockConfigService_Expecter) Watch(ctx any, onChange any) *MockConfigService_Watch_Call {
	return &MockConfigService_Watch_Call{Call: _e.mock.On("Watch", ctx, onChange)}
}

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

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

func (_c *MockConfigService_Watch_Call) RunAndReturn(run func(ctx context.Context, onChange func()) error) *MockConfigService_Watch_Call {
	_c.Call.Return(run)
	return _c
}