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

package mocks

import (
	"context"

	"github.com/bnema/gordon/internal/adapters/dto"
	"github.com/bnema/gordon/internal/adapters/in/cli/remote"
	"github.com/bnema/gordon/internal/domain"
	mock "github.com/stretchr/testify/mock"
)

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

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

	return mock
}

// MockControlPlane is an autogenerated mock type for the ControlPlane type
type MockControlPlane struct {
	mock.Mock
}

type MockControlPlane_Expecter struct {
	mock *mock.Mock
}

func (_m *MockControlPlane) EXPECT() *MockControlPlane_Expecter {
	return &MockControlPlane_Expecter{mock: &_m.Mock}
}

// AddAttachment provides a mock function for the type MockControlPlane
func (_mock *MockControlPlane) 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
}

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

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

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

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

// AddAutoRouteAllowedDomain provides a mock function for the type MockControlPlane
func (_mock *MockControlPlane) 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
}

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

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

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

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

// AddRoute provides a mock function for the type MockControlPlane
func (_mock *MockControlPlane) 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
}

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

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

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

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

// BackupStatus provides a mock function for the type MockControlPlane
func (_mock *MockControlPlane) BackupStatus(ctx context.Context) ([]dto.BackupJob, error) {
	ret := _mock.Called(ctx)

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

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

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

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

func (_c *MockControlPlane_BackupStatus_Call) Run(run func(ctx context.Context)) *MockControlPlane_BackupStatus_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 *MockControlPlane_BackupStatus_Call) Return(backupJobs []dto.BackupJob, err error) *MockControlPlane_BackupStatus_Call {
	_c.Call.Return(backupJobs, err)
	return _c
}

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

// Bootstrap provides a mock function for the type MockControlPlane
func (_mock *MockControlPlane) Bootstrap(ctx context.Context, req dto.BootstrapRequest) (*dto.BootstrapResponse, error) {
	ret := _mock.Called(ctx, req)

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

	var r0 *dto.BootstrapResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, dto.BootstrapRequest) (*dto.BootstrapResponse, error)); ok {
		return returnFunc(ctx, req)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, dto.BootstrapRequest) *dto.BootstrapResponse); ok {
		r0 = returnFunc(ctx, req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dto.BootstrapResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, dto.BootstrapRequest) error); ok {
		r1 = returnFunc(ctx, req)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// Bootstrap is a helper method to define mock.On call
//   - ctx context.Context
//   - req dto.BootstrapRequest
func (_e *MockControlPlane_Expecter) Bootstrap(ctx any, req any) *MockControlPlane_Bootstrap_Call {
	return &MockControlPlane_Bootstrap_Call{Call: _e.mock.On("Bootstrap", ctx, req)}
}

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

func (_c *MockControlPlane_Bootstrap_Call) Return(bootstrapResponse *dto.BootstrapResponse, err error) *MockControlPlane_Bootstrap_Call {
	_c.Call.Return(bootstrapResponse, err)
	return _c
}

func (_c *MockControlPlane_Bootstrap_Call) RunAndReturn(run func(ctx context.Context, req dto.BootstrapRequest) (*dto.BootstrapResponse, error)) *MockControlPlane_Bootstrap_Call {
	_c.Call.Return(run)
	return _c
}

// CleanupOrphanedAttachments provides a mock function for the type MockControlPlane
func (_mock *MockControlPlane) CleanupOrphanedAttachments(ctx context.Context, owner string, stop bool) (*domain.CleanupReport, error) {
	ret := _mock.Called(ctx, owner, stop)

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

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

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

// CleanupOrphanedAttachments is a helper method to define mock.On call
//   - ctx context.Context
//   - owner string
//   - stop bool
func (_e *MockControlPlane_Expecter) CleanupOrphanedAttachments(ctx any, owner any, stop any) *MockControlPlane_CleanupOrphanedAttachments_Call {
	return &MockControlPlane_CleanupOrphanedAttachments_Call{Call: _e.mock.On("CleanupOrphanedAttachments", ctx, owner, stop)}
}

func (_c *MockControlPlane_CleanupOrphanedAttachments_Call) Run(run func(ctx context.Context, owner string, stop bool)) *MockControlPlane_CleanupOrphanedAttachments_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 bool
		if args[2] != nil {
			arg2 = args[2].(bool)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockControlPlane_CleanupOrphanedAttachments_Call) Return(cleanupReport *domain.CleanupReport, err error) *MockControlPlane_CleanupOrphanedAttachments_Call {
	_c.Call.Return(cleanupReport, err)
	return _c
}

func (_c *MockControlPlane_CleanupOrphanedAttachments_Call) RunAndReturn(run func(ctx context.Context, owner string, stop bool) (*domain.CleanupReport, error)) *MockControlPlane_CleanupOrphanedAttachments_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

// DeleteAttachmentSecret is a helper method to define mock.On call
//   - ctx context.Context
//   - domain1 string
//   - service string
//   - key string
func (_e *MockControlPlane_Expecter) DeleteAttachmentSecret(ctx any, domain1 any, service any, key any) *MockControlPlane_DeleteAttachmentSecret_Call {
	return &MockControlPlane_DeleteAttachmentSecret_Call{Call: _e.mock.On("DeleteAttachmentSecret", ctx, domain1, service, key)}
}

func (_c *MockControlPlane_DeleteAttachmentSecret_Call) Run(run func(ctx context.Context, domain1 string, service string, key string)) *MockControlPlane_DeleteAttachmentSecret_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 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

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

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

// DeleteSecret provides a mock function for the type MockControlPlane
func (_mock *MockControlPlane) DeleteSecret(ctx context.Context, secretDomain string, key string) error {
	ret := _mock.Called(ctx, secretDomain, key)

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

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

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

// DeleteSecret is a helper method to define mock.On call
//   - ctx context.Context
//   - secretDomain string
//   - key string
func (_e *MockControlPlane_Expecter) DeleteSecret(ctx any, secretDomain any, key any) *MockControlPlane_DeleteSecret_Call {
	return &MockControlPlane_DeleteSecret_Call{Call: _e.mock.On("DeleteSecret", ctx, secretDomain, key)}
}

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

func (_c *MockControlPlane_DeleteSecret_Call) RunAndReturn(run func(ctx context.Context, secretDomain string, key string) error) *MockControlPlane_DeleteSecret_Call {
	_c.Call.Return(run)
	return _c
}

// Deploy provides a mock function for the type MockControlPlane
func (_mock *MockControlPlane) Deploy(ctx context.Context, deployDomain string) (*remote.DeployResult, error) {
	ret := _mock.Called(ctx, deployDomain)

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

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

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

// Deploy is a helper method to define mock.On call
//   - ctx context.Context
//   - deployDomain string
func (_e *MockControlPlane_Expecter) Deploy(ctx any, deployDomain any) *MockControlPlane_Deploy_Call {
	return &MockControlPlane_Deploy_Call{Call: _e.mock.On("Deploy", ctx, deployDomain)}
}

func (_c *MockControlPlane_Deploy_Call) Run(run func(ctx context.Context, deployDomain string)) *MockControlPlane_Deploy_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 *MockControlPlane_Deploy_Call) Return(deployResult *remote.DeployResult, err error) *MockControlPlane_Deploy_Call {
	_c.Call.Return(deployResult, err)
	return _c
}

func (_c *MockControlPlane_Deploy_Call) RunAndReturn(run func(ctx context.Context, deployDomain string) (*remote.DeployResult, error)) *MockControlPlane_Deploy_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

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

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

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

// DetectDatabases provides a mock function for the type MockControlPlane
func (_mock *MockControlPlane) DetectDatabases(ctx context.Context, backupDomain string) ([]dto.DatabaseInfo, error) {
	ret := _mock.Called(ctx, backupDomain)

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

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

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

// DetectDatabases is a helper method to define mock.On call
//   - ctx context.Context
//   - backupDomain string
func (_e *MockControlPlane_Expecter) DetectDatabases(ctx any, backupDomain any) *MockControlPlane_DetectDatabases_Call {
	return &MockControlPlane_DetectDatabases_Call{Call: _e.mock.On("DetectDatabases", ctx, backupDomain)}
}

func (_c *MockControlPlane_DetectDatabases_Call) Run(run func(ctx context.Context, backupDomain string)) *MockControlPlane_DetectDatabases_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 *MockControlPlane_DetectDatabases_Call) Return(databaseInfos []dto.DatabaseInfo, err error) *MockControlPlane_DetectDatabases_Call {
	_c.Call.Return(databaseInfos, err)
	return _c
}

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

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

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

	var r0 []string
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]string, error)); ok {
		return returnFunc(ctx, imageName)
	}
	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)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, imageName)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

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

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

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

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

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

	var r0 []domain.Route
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]domain.Route, error)); ok {
		return returnFunc(ctx, imageName)
	}
	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)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, imageName)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

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

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

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

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

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

	var r0 map[string][]string
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context) (map[string][]string, error)); ok {
		return returnFunc(ctx)
	}
	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)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = returnFunc(ctx)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

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

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

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

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

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

	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
}

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

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

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

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

// GetAutoRouteAllowedDomains provides a mock function for the type MockControlPlane
func (_mock *MockControlPlane) 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
}

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

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

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

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

// GetConfig provides a mock function for the type MockControlPlane
func (_mock *MockControlPlane) GetConfig(ctx context.Context) (*remote.Config, error) {
	ret := _mock.Called(ctx)

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

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

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

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

func (_c *MockControlPlane_GetConfig_Call) Run(run func(ctx context.Context)) *MockControlPlane_GetConfig_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 *MockControlPlane_GetConfig_Call) Return(config *remote.Config, err error) *MockControlPlane_GetConfig_Call {
	_c.Call.Return(config, err)
	return _c
}

func (_c *MockControlPlane_GetConfig_Call) RunAndReturn(run func(ctx context.Context) (*remote.Config, error)) *MockControlPlane_GetConfig_Call {
	_c.Call.Return(run)
	return _c
}

// GetContainerLogs provides a mock function for the type MockControlPlane
func (_mock *MockControlPlane) GetContainerLogs(ctx context.Context, logDomain string, lines int) ([]string, error) {
	ret := _mock.Called(ctx, logDomain, lines)

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

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

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

// GetContainerLogs is a helper method to define mock.On call
//   - ctx context.Context
//   - logDomain string
//   - lines int
func (_e *MockControlPlane_Expecter) GetContainerLogs(ctx any, logDomain any, lines any) *MockControlPlane_GetContainerLogs_Call {
	return &MockControlPlane_GetContainerLogs_Call{Call: _e.mock.On("GetContainerLogs", ctx, logDomain, lines)}
}

func (_c *MockControlPlane_GetContainerLogs_Call) Run(run func(ctx context.Context, logDomain string, lines int)) *MockControlPlane_GetContainerLogs_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 int
		if args[2] != nil {
			arg2 = args[2].(int)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockControlPlane_GetContainerLogs_Call) Return(strings []string, err error) *MockControlPlane_GetContainerLogs_Call {
	_c.Call.Return(strings, err)
	return _c
}

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

// GetHealth provides a mock function for the type MockControlPlane
func (_mock *MockControlPlane) GetHealth(ctx context.Context) (map[string]*remote.RouteHealth, error) {
	ret := _mock.Called(ctx)

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

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

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

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

func (_c *MockControlPlane_GetHealth_Call) Run(run func(ctx context.Context)) *MockControlPlane_GetHealth_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 *MockControlPlane_GetHealth_Call) Return(stringToRouteHealth map[string]*remote.RouteHealth, err error) *MockControlPlane_GetHealth_Call {
	_c.Call.Return(stringToRouteHealth, err)
	return _c
}

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

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

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

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

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

// GetProcessLogs is a helper method to define mock.On call
//   - ctx context.Context
//   - lines int
func (_e *MockControlPlane_Expecter) GetProcessLogs(ctx any, lines any) *MockControlPlane_GetProcessLogs_Call {
	return &MockControlPlane_GetProcessLogs_Call{Call: _e.mock.On("GetProcessLogs", ctx, lines)}
}

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

func (_c *MockControlPlane_GetProcessLogs_Call) Return(strings []string, err error) *MockControlPlane_GetProcessLogs_Call {
	_c.Call.Return(strings, err)
	return _c
}

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

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

	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, routeDomain)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) *domain.Route); ok {
		r0 = returnFunc(ctx, routeDomain)
	} 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, routeDomain)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

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

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

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

// GetStatus provides a mock function for the type MockControlPlane
func (_mock *MockControlPlane) GetStatus(ctx context.Context) (*remote.Status, error) {
	ret := _mock.Called(ctx)

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

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

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

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

func (_c *MockControlPlane_GetStatus_Call) Run(run func(ctx context.Context)) *MockControlPlane_GetStatus_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 *MockControlPlane_GetStatus_Call) Return(status *remote.Status, err error) *MockControlPlane_GetStatus_Call {
	_c.Call.Return(status, err)
	return _c
}

func (_c *MockControlPlane_GetStatus_Call) RunAndReturn(run func(ctx context.Context) (*remote.Status, error)) *MockControlPlane_GetStatus_Call {
	_c.Call.Return(run)
	return _c
}

// GetTLSStatus provides a mock function for the type MockControlPlane
func (_mock *MockControlPlane) GetTLSStatus(ctx context.Context) (*dto.TLSStatusResponse, error) {
	ret := _mock.Called(ctx)

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

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

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

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

func (_c *MockControlPlane_GetTLSStatus_Call) Run(run func(ctx context.Context)) *MockControlPlane_GetTLSStatus_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 *MockControlPlane_GetTLSStatus_Call) Return(tLSStatusResponse *dto.TLSStatusResponse, err error) *MockControlPlane_GetTLSStatus_Call {
	_c.Call.Return(tLSStatusResponse, err)
	return _c
}

func (_c *MockControlPlane_GetTLSStatus_Call) RunAndReturn(run func(ctx context.Context) (*dto.TLSStatusResponse, error)) *MockControlPlane_GetTLSStatus_Call {
	_c.Call.Return(run)
	return _c
}

// GetTrafficStatus provides a mock function for the type MockControlPlane
func (_mock *MockControlPlane) GetTrafficStatus(ctx context.Context) (*dto.TrafficStatusResponse, error) {
	ret := _mock.Called(ctx)

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

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

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

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

func (_c *MockControlPlane_GetTrafficStatus_Call) Run(run func(ctx context.Context)) *MockControlPlane_GetTrafficStatus_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 *MockControlPlane_GetTrafficStatus_Call) Return(trafficStatusResponse *dto.TrafficStatusResponse, err error) *MockControlPlane_GetTrafficStatus_Call {
	_c.Call.Return(trafficStatusResponse, err)
	return _c
}

func (_c *MockControlPlane_GetTrafficStatus_Call) RunAndReturn(run func(ctx context.Context) (*dto.TrafficStatusResponse, error)) *MockControlPlane_GetTrafficStatus_Call {
	_c.Call.Return(run)
	return _c
}

// ListBackups provides a mock function for the type MockControlPlane
func (_mock *MockControlPlane) ListBackups(ctx context.Context, backupDomain string) ([]dto.BackupJob, error) {
	ret := _mock.Called(ctx, backupDomain)

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

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

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

// ListBackups is a helper method to define mock.On call
//   - ctx context.Context
//   - backupDomain string
func (_e *MockControlPlane_Expecter) ListBackups(ctx any, backupDomain any) *MockControlPlane_ListBackups_Call {
	return &MockControlPlane_ListBackups_Call{Call: _e.mock.On("ListBackups", ctx, backupDomain)}
}

func (_c *MockControlPlane_ListBackups_Call) Run(run func(ctx context.Context, backupDomain string)) *MockControlPlane_ListBackups_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 *MockControlPlane_ListBackups_Call) Return(backupJobs []dto.BackupJob, err error) *MockControlPlane_ListBackups_Call {
	_c.Call.Return(backupJobs, err)
	return _c
}

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

// ListNetworks provides a mock function for the type MockControlPlane
func (_mock *MockControlPlane) ListNetworks(ctx context.Context) ([]*domain.NetworkInfo, error) {
	ret := _mock.Called(ctx)

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

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

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

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

func (_c *MockControlPlane_ListNetworks_Call) Run(run func(ctx context.Context)) *MockControlPlane_ListNetworks_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 *MockControlPlane_ListNetworks_Call) Return(networkInfos []*domain.NetworkInfo, err error) *MockControlPlane_ListNetworks_Call {
	_c.Call.Return(networkInfos, err)
	return _c
}

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

// ListOrphanedAttachments provides a mock function for the type MockControlPlane
func (_mock *MockControlPlane) ListOrphanedAttachments(ctx context.Context) ([]domain.CleanupAttachment, error) {
	ret := _mock.Called(ctx)

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

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

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

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

func (_c *MockControlPlane_ListOrphanedAttachments_Call) Run(run func(ctx context.Context)) *MockControlPlane_ListOrphanedAttachments_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 *MockControlPlane_ListOrphanedAttachments_Call) Return(cleanupAttachments []domain.CleanupAttachment, err error) *MockControlPlane_ListOrphanedAttachments_Call {
	_c.Call.Return(cleanupAttachments, err)
	return _c
}

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

// ListRoutesWithDetails provides a mock function for the type MockControlPlane
func (_mock *MockControlPlane) ListRoutesWithDetails(ctx context.Context) ([]remote.RouteInfo, error) {
	ret := _mock.Called(ctx)

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

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

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

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

func (_c *MockControlPlane_ListRoutesWithDetails_Call) Run(run func(ctx context.Context)) *MockControlPlane_ListRoutesWithDetails_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 *MockControlPlane_ListRoutesWithDetails_Call) Return(vs []remote.RouteInfo, err error) *MockControlPlane_ListRoutesWithDetails_Call {
	_c.Call.Return(vs, err)
	return _c
}

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

// ListSecretsWithAttachments provides a mock function for the type MockControlPlane
func (_mock *MockControlPlane) ListSecretsWithAttachments(ctx context.Context, secretDomain string) (*remote.SecretsListResult, error) {
	ret := _mock.Called(ctx, secretDomain)

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

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

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

// ListSecretsWithAttachments is a helper method to define mock.On call
//   - ctx context.Context
//   - secretDomain string
func (_e *MockControlPlane_Expecter) ListSecretsWithAttachments(ctx any, secretDomain any) *MockControlPlane_ListSecretsWithAttachments_Call {
	return &MockControlPlane_ListSecretsWithAttachments_Call{Call: _e.mock.On("ListSecretsWithAttachments", ctx, secretDomain)}
}

func (_c *MockControlPlane_ListSecretsWithAttachments_Call) Run(run func(ctx context.Context, secretDomain string)) *MockControlPlane_ListSecretsWithAttachments_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 *MockControlPlane_ListSecretsWithAttachments_Call) Return(secretsListResult *remote.SecretsListResult, err error) *MockControlPlane_ListSecretsWithAttachments_Call {
	_c.Call.Return(secretsListResult, err)
	return _c
}

func (_c *MockControlPlane_ListSecretsWithAttachments_Call) RunAndReturn(run func(ctx context.Context, secretDomain string) (*remote.SecretsListResult, error)) *MockControlPlane_ListSecretsWithAttachments_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	var r0 []string
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]string, error)); ok {
		return returnFunc(ctx, repository)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []string); ok {
		r0 = returnFunc(ctx, repository)
	} 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, repository)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ListTags is a helper method to define mock.On call
//   - ctx context.Context
//   - repository string
func (_e *MockControlPlane_Expecter) ListTags(ctx any, repository any) *MockControlPlane_ListTags_Call {
	return &MockControlPlane_ListTags_Call{Call: _e.mock.On("ListTags", ctx, repository)}
}

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

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

// ListVolumeBackups provides a mock function for the type MockControlPlane
func (_mock *MockControlPlane) ListVolumeBackups(ctx context.Context, backupDomain string) ([]dto.VolumeBackupJob, error) {
	ret := _mock.Called(ctx, backupDomain)

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

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

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

// ListVolumeBackups is a helper method to define mock.On call
//   - ctx context.Context
//   - backupDomain string
func (_e *MockControlPlane_Expecter) ListVolumeBackups(ctx any, backupDomain any) *MockControlPlane_ListVolumeBackups_Call {
	return &MockControlPlane_ListVolumeBackups_Call{Call: _e.mock.On("ListVolumeBackups", ctx, backupDomain)}
}

func (_c *MockControlPlane_ListVolumeBackups_Call) Run(run func(ctx context.Context, backupDomain string)) *MockControlPlane_ListVolumeBackups_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 *MockControlPlane_ListVolumeBackups_Call) Return(volumeBackupJobs []dto.VolumeBackupJob, err error) *MockControlPlane_ListVolumeBackups_Call {
	_c.Call.Return(volumeBackupJobs, err)
	return _c
}

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

// ListVolumes provides a mock function for the type MockControlPlane
func (_mock *MockControlPlane) ListVolumes(ctx context.Context) ([]dto.Volume, error) {
	ret := _mock.Called(ctx)

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

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

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

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

func (_c *MockControlPlane_ListVolumes_Call) Run(run func(ctx context.Context)) *MockControlPlane_ListVolumes_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 *MockControlPlane_ListVolumes_Call) Return(volumes []dto.Volume, err error) *MockControlPlane_ListVolumes_Call {
	_c.Call.Return(volumes, err)
	return _c
}

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

// PruneVolumes provides a mock function for the type MockControlPlane
func (_mock *MockControlPlane) PruneVolumes(ctx context.Context, req dto.VolumePruneRequest) (*dto.VolumePruneResponse, error) {
	ret := _mock.Called(ctx, req)

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

	var r0 *dto.VolumePruneResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, dto.VolumePruneRequest) (*dto.VolumePruneResponse, error)); ok {
		return returnFunc(ctx, req)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, dto.VolumePruneRequest) *dto.VolumePruneResponse); ok {
		r0 = returnFunc(ctx, req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dto.VolumePruneResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, dto.VolumePruneRequest) error); ok {
		r1 = returnFunc(ctx, req)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// PruneVolumes is a helper method to define mock.On call
//   - ctx context.Context
//   - req dto.VolumePruneRequest
func (_e *MockControlPlane_Expecter) PruneVolumes(ctx any, req any) *MockControlPlane_PruneVolumes_Call {
	return &MockControlPlane_PruneVolumes_Call{Call: _e.mock.On("PruneVolumes", ctx, req)}
}

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

func (_c *MockControlPlane_PruneVolumes_Call) Return(volumePruneResponse *dto.VolumePruneResponse, err error) *MockControlPlane_PruneVolumes_Call {
	_c.Call.Return(volumePruneResponse, err)
	return _c
}

func (_c *MockControlPlane_PruneVolumes_Call) RunAndReturn(run func(ctx context.Context, req dto.VolumePruneRequest) (*dto.VolumePruneResponse, error)) *MockControlPlane_PruneVolumes_Call {
	_c.Call.Return(run)
	return _c
}

// Reload provides a mock function for the type MockControlPlane
func (_mock *MockControlPlane) 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
}

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

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

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

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

// RemoveAttachment provides a mock function for the type MockControlPlane
func (_mock *MockControlPlane) 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
}

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

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

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

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

// RemoveAutoRouteAllowedDomain provides a mock function for the type MockControlPlane
func (_mock *MockControlPlane) 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
}

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

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

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

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

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

	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, routeDomain)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

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

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

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

// Restart provides a mock function for the type MockControlPlane
func (_mock *MockControlPlane) Restart(ctx context.Context, restartDomain string, withAttachments bool) (*remote.RestartResult, error) {
	ret := _mock.Called(ctx, restartDomain, withAttachments)

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

	var r0 *remote.RestartResult
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, bool) (*remote.RestartResult, error)); ok {
		return returnFunc(ctx, restartDomain, withAttachments)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, bool) *remote.RestartResult); ok {
		r0 = returnFunc(ctx, restartDomain, withAttachments)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*remote.RestartResult)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, bool) error); ok {
		r1 = returnFunc(ctx, restartDomain, withAttachments)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// Restart is a helper method to define mock.On call
//   - ctx context.Context
//   - restartDomain string
//   - withAttachments bool
func (_e *MockControlPlane_Expecter) Restart(ctx any, restartDomain any, withAttachments any) *MockControlPlane_Restart_Call {
	return &MockControlPlane_Restart_Call{Call: _e.mock.On("Restart", ctx, restartDomain, withAttachments)}
}

func (_c *MockControlPlane_Restart_Call) Run(run func(ctx context.Context, restartDomain string, withAttachments bool)) *MockControlPlane_Restart_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 bool
		if args[2] != nil {
			arg2 = args[2].(bool)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockControlPlane_Restart_Call) Return(restartResult *remote.RestartResult, err error) *MockControlPlane_Restart_Call {
	_c.Call.Return(restartResult, err)
	return _c
}

func (_c *MockControlPlane_Restart_Call) RunAndReturn(run func(ctx context.Context, restartDomain string, withAttachments bool) (*remote.RestartResult, error)) *MockControlPlane_Restart_Call {
	_c.Call.Return(run)
	return _c
}

// RunBackup provides a mock function for the type MockControlPlane
func (_mock *MockControlPlane) RunBackup(ctx context.Context, backupDomain string, dbName string) (*dto.BackupRunResponse, error) {
	ret := _mock.Called(ctx, backupDomain, dbName)

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

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

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

// RunBackup is a helper method to define mock.On call
//   - ctx context.Context
//   - backupDomain string
//   - dbName string
func (_e *MockControlPlane_Expecter) RunBackup(ctx any, backupDomain any, dbName any) *MockControlPlane_RunBackup_Call {
	return &MockControlPlane_RunBackup_Call{Call: _e.mock.On("RunBackup", ctx, backupDomain, dbName)}
}

func (_c *MockControlPlane_RunBackup_Call) Run(run func(ctx context.Context, backupDomain string, dbName string)) *MockControlPlane_RunBackup_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 *MockControlPlane_RunBackup_Call) Return(backupRunResponse *dto.BackupRunResponse, err error) *MockControlPlane_RunBackup_Call {
	_c.Call.Return(backupRunResponse, err)
	return _c
}

func (_c *MockControlPlane_RunBackup_Call) RunAndReturn(run func(ctx context.Context, backupDomain string, dbName string) (*dto.BackupRunResponse, error)) *MockControlPlane_RunBackup_Call {
	_c.Call.Return(run)
	return _c
}

// RunVolumeBackups provides a mock function for the type MockControlPlane
func (_mock *MockControlPlane) RunVolumeBackups(ctx context.Context, backupDomain string, volumeName string) (*dto.VolumeBackupRunResponse, error) {
	ret := _mock.Called(ctx, backupDomain, volumeName)

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

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

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

// RunVolumeBackups is a helper method to define mock.On call
//   - ctx context.Context
//   - backupDomain string
//   - volumeName string
func (_e *MockControlPlane_Expecter) RunVolumeBackups(ctx any, backupDomain any, volumeName any) *MockControlPlane_RunVolumeBackups_Call {
	return &MockControlPlane_RunVolumeBackups_Call{Call: _e.mock.On("RunVolumeBackups", ctx, backupDomain, volumeName)}
}

func (_c *MockControlPlane_RunVolumeBackups_Call) Run(run func(ctx context.Context, backupDomain string, volumeName string)) *MockControlPlane_RunVolumeBackups_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 *MockControlPlane_RunVolumeBackups_Call) Return(volumeBackupRunResponse *dto.VolumeBackupRunResponse, err error) *MockControlPlane_RunVolumeBackups_Call {
	_c.Call.Return(volumeBackupRunResponse, err)
	return _c
}

func (_c *MockControlPlane_RunVolumeBackups_Call) RunAndReturn(run func(ctx context.Context, backupDomain string, volumeName string) (*dto.VolumeBackupRunResponse, error)) *MockControlPlane_RunVolumeBackups_Call {
	_c.Call.Return(run)
	return _c
}

// SetAttachmentSecrets provides a mock function for the type MockControlPlane
func (_mock *MockControlPlane) SetAttachmentSecrets(ctx context.Context, domain1 string, service string, secrets map[string]string) error {
	ret := _mock.Called(ctx, domain1, service, secrets)

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

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

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

// SetAttachmentSecrets is a helper method to define mock.On call
//   - ctx context.Context
//   - domain1 string
//   - service string
//   - secrets map[string]string
func (_e *MockControlPlane_Expecter) SetAttachmentSecrets(ctx any, domain1 any, service any, secrets any) *MockControlPlane_SetAttachmentSecrets_Call {
	return &MockControlPlane_SetAttachmentSecrets_Call{Call: _e.mock.On("SetAttachmentSecrets", ctx, domain1, service, secrets)}
}

func (_c *MockControlPlane_SetAttachmentSecrets_Call) Run(run func(ctx context.Context, domain1 string, service string, secrets map[string]string)) *MockControlPlane_SetAttachmentSecrets_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[string]string
		if args[3] != nil {
			arg3 = args[3].(map[string]string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

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

func (_c *MockControlPlane_SetAttachmentSecrets_Call) RunAndReturn(run func(ctx context.Context, domain1 string, service string, secrets map[string]string) error) *MockControlPlane_SetAttachmentSecrets_Call {
	_c.Call.Return(run)
	return _c
}

// SetSecrets provides a mock function for the type MockControlPlane
func (_mock *MockControlPlane) SetSecrets(ctx context.Context, secretDomain string, secrets map[string]string) error {
	ret := _mock.Called(ctx, secretDomain, secrets)

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

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

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

// SetSecrets is a helper method to define mock.On call
//   - ctx context.Context
//   - secretDomain string
//   - secrets map[string]string
func (_e *MockControlPlane_Expecter) SetSecrets(ctx any, secretDomain any, secrets any) *MockControlPlane_SetSecrets_Call {
	return &MockControlPlane_SetSecrets_Call{Call: _e.mock.On("SetSecrets", ctx, secretDomain, secrets)}
}

func (_c *MockControlPlane_SetSecrets_Call) Run(run func(ctx context.Context, secretDomain string, secrets map[string]string)) *MockControlPlane_SetSecrets_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 map[string]string
		if args[2] != nil {
			arg2 = args[2].(map[string]string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

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

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

// StreamContainerLogs provides a mock function for the type MockControlPlane
func (_mock *MockControlPlane) StreamContainerLogs(ctx context.Context, logDomain string, lines int) (<-chan string, error) {
	ret := _mock.Called(ctx, logDomain, lines)

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

	var r0 <-chan string
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, int) (<-chan string, error)); ok {
		return returnFunc(ctx, logDomain, lines)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, int) <-chan string); ok {
		r0 = returnFunc(ctx, logDomain, lines)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(<-chan string)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, int) error); ok {
		r1 = returnFunc(ctx, logDomain, lines)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// StreamContainerLogs is a helper method to define mock.On call
//   - ctx context.Context
//   - logDomain string
//   - lines int
func (_e *MockControlPlane_Expecter) StreamContainerLogs(ctx any, logDomain any, lines any) *MockControlPlane_StreamContainerLogs_Call {
	return &MockControlPlane_StreamContainerLogs_Call{Call: _e.mock.On("StreamContainerLogs", ctx, logDomain, lines)}
}

func (_c *MockControlPlane_StreamContainerLogs_Call) Run(run func(ctx context.Context, logDomain string, lines int)) *MockControlPlane_StreamContainerLogs_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 int
		if args[2] != nil {
			arg2 = args[2].(int)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockControlPlane_StreamContainerLogs_Call) Return(stringCh <-chan string, err error) *MockControlPlane_StreamContainerLogs_Call {
	_c.Call.Return(stringCh, err)
	return _c
}

func (_c *MockControlPlane_StreamContainerLogs_Call) RunAndReturn(run func(ctx context.Context, logDomain string, lines int) (<-chan string, error)) *MockControlPlane_StreamContainerLogs_Call {
	_c.Call.Return(run)
	return _c
}

// StreamProcessLogs provides a mock function for the type MockControlPlane
func (_mock *MockControlPlane) StreamProcessLogs(ctx context.Context, lines int) (<-chan string, error) {
	ret := _mock.Called(ctx, lines)

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

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

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

// StreamProcessLogs is a helper method to define mock.On call
//   - ctx context.Context
//   - lines int
func (_e *MockControlPlane_Expecter) StreamProcessLogs(ctx any, lines any) *MockControlPlane_StreamProcessLogs_Call {
	return &MockControlPlane_StreamProcessLogs_Call{Call: _e.mock.On("StreamProcessLogs", ctx, lines)}
}

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

func (_c *MockControlPlane_StreamProcessLogs_Call) Return(stringCh <-chan string, err error) *MockControlPlane_StreamProcessLogs_Call {
	_c.Call.Return(stringCh, err)
	return _c
}

func (_c *MockControlPlane_StreamProcessLogs_Call) RunAndReturn(run func(ctx context.Context, lines int) (<-chan string, error)) *MockControlPlane_StreamProcessLogs_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateRoute provides a mock function for the type MockControlPlane
func (_mock *MockControlPlane) 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
}

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

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

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

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

// VolumeBackupStatus provides a mock function for the type MockControlPlane
func (_mock *MockControlPlane) VolumeBackupStatus(ctx context.Context) ([]dto.VolumeBackupJob, error) {
	ret := _mock.Called(ctx)

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

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

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

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

func (_c *MockControlPlane_VolumeBackupStatus_Call) Run(run func(ctx context.Context)) *MockControlPlane_VolumeBackupStatus_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 *MockControlPlane_VolumeBackupStatus_Call) Return(volumeBackupJobs []dto.VolumeBackupJob, err error) *MockControlPlane_VolumeBackupStatus_Call {
	_c.Call.Return(volumeBackupJobs, err)
	return _c
}

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