// 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 {
	if helper, ok := t.(interface{ Helper() }); ok {
		helper.Helper()
	}

	mock := &MockControlPlane{}
	mock.Mock.Test(t)

	t.Cleanup(func() {
		if helper, ok := t.(interface{ Helper() }); ok {
			helper.Helper()
		}
		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}
}

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

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

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

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

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

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

func (_c *MockControlPlane_ApplyApp_Call) Return(appApplyResponse *dto.AppApplyResponse, err error) *MockControlPlane_ApplyApp_Call {
	_c.Call.Return(appApplyResponse, err)
	return _c
}

func (_c *MockControlPlane_ApplyApp_Call) RunAndReturn(run func(ctx context.Context, req dto.AppApplyRequest) (*dto.AppApplyResponse, error)) *MockControlPlane_ApplyApp_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
}

// DeleteAppSecret provides a mock function for the type MockControlPlane
func (_mock *MockControlPlane) DeleteAppSecret(ctx context.Context, app string, req dto.AppSecretDeleteRequest) error {
	ret := _mock.Called(ctx, app, req)

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

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

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

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

func (_c *MockControlPlane_DeleteAppSecret_Call) Run(run func(ctx context.Context, app string, req dto.AppSecretDeleteRequest)) *MockControlPlane_DeleteAppSecret_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 dto.AppSecretDeleteRequest
		if args[2] != nil {
			arg2 = args[2].(dto.AppSecretDeleteRequest)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

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

func (_c *MockControlPlane_DeleteAppSecret_Call) RunAndReturn(run func(ctx context.Context, app string, req dto.AppSecretDeleteRequest) error) *MockControlPlane_DeleteAppSecret_Call {
	_c.Call.Return(run)
	return _c
}

// DeployApp provides a mock function for the type MockControlPlane
func (_mock *MockControlPlane) DeployApp(ctx context.Context, app string, req dto.AppDeployRequest) (*dto.AppDeployResponse, string, error) {
	ret := _mock.Called(ctx, app, req)

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

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

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

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

func (_c *MockControlPlane_DeployApp_Call) Run(run func(ctx context.Context, app string, req dto.AppDeployRequest)) *MockControlPlane_DeployApp_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 dto.AppDeployRequest
		if args[2] != nil {
			arg2 = args[2].(dto.AppDeployRequest)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockControlPlane_DeployApp_Call) Return(appDeployResponse *dto.AppDeployResponse, s string, err error) *MockControlPlane_DeployApp_Call {
	_c.Call.Return(appDeployResponse, s, err)
	return _c
}

func (_c *MockControlPlane_DeployApp_Call) RunAndReturn(run func(ctx context.Context, app string, req dto.AppDeployRequest) (*dto.AppDeployResponse, string, error)) *MockControlPlane_DeployApp_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

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

func (_c *MockControlPlane_DiffApp_Call) Run(run func(ctx context.Context, app string)) *MockControlPlane_DiffApp_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_DiffApp_Call) Return(appDiffResponse *dto.AppDiffResponse, err error) *MockControlPlane_DiffApp_Call {
	_c.Call.Return(appDiffResponse, err)
	return _c
}

func (_c *MockControlPlane_DiffApp_Call) RunAndReturn(run func(ctx context.Context, app string) (*dto.AppDiffResponse, error)) *MockControlPlane_DiffApp_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

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

func (_c *MockControlPlane_GetCA_Call) Run(run func(ctx context.Context)) *MockControlPlane_GetCA_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_GetCA_Call) Return(cAResponse *dto.CAResponse, err error) *MockControlPlane_GetCA_Call {
	_c.Call.Return(cAResponse, err)
	return _c
}

func (_c *MockControlPlane_GetCA_Call) RunAndReturn(run func(ctx context.Context) (*dto.CAResponse, error)) *MockControlPlane_GetCA_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
}

// 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
}

// 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
}

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

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

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

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

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

func (_c *MockControlPlane_ListAppSecrets_Call) Run(run func(ctx context.Context, app string, service string)) *MockControlPlane_ListAppSecrets_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_ListAppSecrets_Call) Return(appSecretMetadataDTOs []dto.AppSecretMetadataDTO, err error) *MockControlPlane_ListAppSecrets_Call {
	_c.Call.Return(appSecretMetadataDTOs, err)
	return _c
}

func (_c *MockControlPlane_ListAppSecrets_Call) RunAndReturn(run func(ctx context.Context, app string, service string) ([]dto.AppSecretMetadataDTO, error)) *MockControlPlane_ListAppSecrets_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

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

func (_c *MockControlPlane_ListApps_Call) Run(run func(ctx context.Context)) *MockControlPlane_ListApps_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_ListApps_Call) Return(appSummaryDTOs []dto.AppSummaryDTO, err error) *MockControlPlane_ListApps_Call {
	_c.Call.Return(appSummaryDTOs, err)
	return _c
}

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

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

	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, app)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []dto.BackupJob); ok {
		r0 = returnFunc(ctx, app)
	} 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, app)
	} 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
//   - app string
func (_e *MockControlPlane_Expecter) ListBackups(ctx any, app any) *MockControlPlane_ListBackups_Call {
	return &MockControlPlane_ListBackups_Call{Call: _e.mock.On("ListBackups", ctx, app)}
}

func (_c *MockControlPlane_ListBackups_Call) Run(run func(ctx context.Context, app 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, app 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
}

// 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, app string) ([]dto.VolumeBackupJob, error) {
	ret := _mock.Called(ctx, app)

	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, app)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []dto.VolumeBackupJob); ok {
		r0 = returnFunc(ctx, app)
	} 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, app)
	} 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
//   - app string
func (_e *MockControlPlane_Expecter) ListVolumeBackups(ctx any, app any) *MockControlPlane_ListVolumeBackups_Call {
	return &MockControlPlane_ListVolumeBackups_Call{Call: _e.mock.On("ListVolumeBackups", ctx, app)}
}

func (_c *MockControlPlane_ListVolumeBackups_Call) Run(run func(ctx context.Context, app 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, app 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
}

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

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

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

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

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

func (_c *MockControlPlane_OperationByKey_Call) Run(run func(ctx context.Context, app string, key string)) *MockControlPlane_OperationByKey_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_OperationByKey_Call) Return(appDeployResponse *dto.AppDeployResponse, err error) *MockControlPlane_OperationByKey_Call {
	_c.Call.Return(appDeployResponse, err)
	return _c
}

func (_c *MockControlPlane_OperationByKey_Call) RunAndReturn(run func(ctx context.Context, app string, key string) (*dto.AppDeployResponse, error)) *MockControlPlane_OperationByKey_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
}

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

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

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

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

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

func (_c *MockControlPlane_RemoveApp_Call) Run(run func(ctx context.Context, app string)) *MockControlPlane_RemoveApp_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_RemoveApp_Call) Return(appDeployResponse *dto.AppDeployResponse, s string, err error) *MockControlPlane_RemoveApp_Call {
	_c.Call.Return(appDeployResponse, s, err)
	return _c
}

func (_c *MockControlPlane_RemoveApp_Call) RunAndReturn(run func(ctx context.Context, app string) (*dto.AppDeployResponse, string, error)) *MockControlPlane_RemoveApp_Call {
	_c.Call.Return(run)
	return _c
}

// RestartApp provides a mock function for the type MockControlPlane
func (_mock *MockControlPlane) RestartApp(ctx context.Context, app string, service string, all bool) (*dto.AppDeployResponse, string, error) {
	ret := _mock.Called(ctx, app, service, all)

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

	var r0 *dto.AppDeployResponse
	var r1 string
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, bool) (*dto.AppDeployResponse, string, error)); ok {
		return returnFunc(ctx, app, service, all)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, bool) *dto.AppDeployResponse); ok {
		r0 = returnFunc(ctx, app, service, all)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dto.AppDeployResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, bool) string); ok {
		r1 = returnFunc(ctx, app, service, all)
	} else {
		r1 = ret.Get(1).(string)
	}
	if returnFunc, ok := ret.Get(2).(func(context.Context, string, string, bool) error); ok {
		r2 = returnFunc(ctx, app, service, all)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// RestartApp is a helper method to define mock.On call
//   - ctx context.Context
//   - app string
//   - service string
//   - all bool
func (_e *MockControlPlane_Expecter) RestartApp(ctx any, app any, service any, all any) *MockControlPlane_RestartApp_Call {
	return &MockControlPlane_RestartApp_Call{Call: _e.mock.On("RestartApp", ctx, app, service, all)}
}

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

func (_c *MockControlPlane_RestartApp_Call) Return(appDeployResponse *dto.AppDeployResponse, s string, err error) *MockControlPlane_RestartApp_Call {
	_c.Call.Return(appDeployResponse, s, err)
	return _c
}

func (_c *MockControlPlane_RestartApp_Call) RunAndReturn(run func(ctx context.Context, app string, service string, all bool) (*dto.AppDeployResponse, string, error)) *MockControlPlane_RestartApp_Call {
	_c.Call.Return(run)
	return _c
}

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

	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, string) (*dto.BackupRunResponse, error)); ok {
		return returnFunc(ctx, app, service, database)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) *dto.BackupRunResponse); ok {
		r0 = returnFunc(ctx, app, service, database)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dto.BackupRunResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
		r1 = returnFunc(ctx, app, service, database)
	} 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
//   - app string
//   - service string
//   - database string
func (_e *MockControlPlane_Expecter) RunBackup(ctx any, app any, service any, database any) *MockControlPlane_RunBackup_Call {
	return &MockControlPlane_RunBackup_Call{Call: _e.mock.On("RunBackup", ctx, app, service, database)}
}

func (_c *MockControlPlane_RunBackup_Call) Run(run func(ctx context.Context, app string, service string, database 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)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	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, app string, service string, database 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, app string, service string, volume string) (*dto.VolumeBackupRunResponse, error) {
	ret := _mock.Called(ctx, app, service, volume)

	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, string) (*dto.VolumeBackupRunResponse, error)); ok {
		return returnFunc(ctx, app, service, volume)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) *dto.VolumeBackupRunResponse); ok {
		r0 = returnFunc(ctx, app, service, volume)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dto.VolumeBackupRunResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
		r1 = returnFunc(ctx, app, service, volume)
	} 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
//   - app string
//   - service string
//   - volume string
func (_e *MockControlPlane_Expecter) RunVolumeBackups(ctx any, app any, service any, volume any) *MockControlPlane_RunVolumeBackups_Call {
	return &MockControlPlane_RunVolumeBackups_Call{Call: _e.mock.On("RunVolumeBackups", ctx, app, service, volume)}
}

func (_c *MockControlPlane_RunVolumeBackups_Call) Run(run func(ctx context.Context, app string, service string, volume 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)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	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, app string, service string, volume string) (*dto.VolumeBackupRunResponse, error)) *MockControlPlane_RunVolumeBackups_Call {
	_c.Call.Return(run)
	return _c
}

// SetAppSecrets provides a mock function for the type MockControlPlane
func (_mock *MockControlPlane) SetAppSecrets(ctx context.Context, app string, req dto.AppSecretSetRequest) error {
	ret := _mock.Called(ctx, app, req)

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

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

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

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

func (_c *MockControlPlane_SetAppSecrets_Call) Run(run func(ctx context.Context, app string, req dto.AppSecretSetRequest)) *MockControlPlane_SetAppSecrets_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 dto.AppSecretSetRequest
		if args[2] != nil {
			arg2 = args[2].(dto.AppSecretSetRequest)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

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

func (_c *MockControlPlane_SetAppSecrets_Call) RunAndReturn(run func(ctx context.Context, app string, req dto.AppSecretSetRequest) error) *MockControlPlane_SetAppSecrets_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

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

func (_c *MockControlPlane_ShowApp_Call) Run(run func(ctx context.Context, app string)) *MockControlPlane_ShowApp_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_ShowApp_Call) Return(appShowResponse *dto.AppShowResponse, err error) *MockControlPlane_ShowApp_Call {
	_c.Call.Return(appShowResponse, err)
	return _c
}

func (_c *MockControlPlane_ShowApp_Call) RunAndReturn(run func(ctx context.Context, app string) (*dto.AppShowResponse, error)) *MockControlPlane_ShowApp_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

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

func (_c *MockControlPlane_StartApp_Call) Run(run func(ctx context.Context, app string)) *MockControlPlane_StartApp_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_StartApp_Call) Return(appDeployResponse *dto.AppDeployResponse, s string, err error) *MockControlPlane_StartApp_Call {
	_c.Call.Return(appDeployResponse, s, err)
	return _c
}

func (_c *MockControlPlane_StartApp_Call) RunAndReturn(run func(ctx context.Context, app string) (*dto.AppDeployResponse, string, error)) *MockControlPlane_StartApp_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

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

func (_c *MockControlPlane_StopApp_Call) Run(run func(ctx context.Context, app string)) *MockControlPlane_StopApp_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_StopApp_Call) Return(appDeployResponse *dto.AppDeployResponse, s string, err error) *MockControlPlane_StopApp_Call {
	_c.Call.Return(appDeployResponse, s, err)
	return _c
}

func (_c *MockControlPlane_StopApp_Call) RunAndReturn(run func(ctx context.Context, app string) (*dto.AppDeployResponse, string, error)) *MockControlPlane_StopApp_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
}

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

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

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

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

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

func (_c *MockControlPlane_VerifyAuth_Call) Run(run func(ctx context.Context)) *MockControlPlane_VerifyAuth_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_VerifyAuth_Call) Return(authVerifyResponse *dto.AuthVerifyResponse, err error) *MockControlPlane_VerifyAuth_Call {
	_c.Call.Return(authVerifyResponse, err)
	return _c
}

func (_c *MockControlPlane_VerifyAuth_Call) RunAndReturn(run func(ctx context.Context) (*dto.AuthVerifyResponse, error)) *MockControlPlane_VerifyAuth_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
}