// Code generated by MockGen. DO NOT EDIT.
// Source: runtime/runtime.go
//
// Generated by this command:
//
//	mockgen -package=mockruntime -source=runtime/runtime.go -destination=./mocks/mockruntime/runtime.go
//

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

import (
	context "context"
	io "io"
	reflect "reflect"

	exec "github.com/srl-labs/containerlab/exec"
	links "github.com/srl-labs/containerlab/links"
	runtime "github.com/srl-labs/containerlab/runtime"
	types "github.com/srl-labs/containerlab/types"
	gomock "go.uber.org/mock/gomock"
)

// MockContainerRuntime is a mock of ContainerRuntime interface.
type MockContainerRuntime struct {
	ctrl     *gomock.Controller
	recorder *MockContainerRuntimeMockRecorder
	isgomock struct{}
}

// MockContainerRuntimeMockRecorder is the mock recorder for MockContainerRuntime.
type MockContainerRuntimeMockRecorder struct {
	mock *MockContainerRuntime
}

// NewMockContainerRuntime creates a new mock instance.
func NewMockContainerRuntime(ctrl *gomock.Controller) *MockContainerRuntime {
	mock := &MockContainerRuntime{ctrl: ctrl}
	mock.recorder = &MockContainerRuntimeMockRecorder{mock}
	return mock
}

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

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

// CheckConnection indicates an expected call of CheckConnection.
func (mr *MockContainerRuntimeMockRecorder) CheckConnection(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckConnection", reflect.TypeOf((*MockContainerRuntime)(nil).CheckConnection), ctx)
}

// Config mocks base method.
func (m *MockContainerRuntime) Config() runtime.RuntimeConfig {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Config")
	ret0, _ := ret[0].(runtime.RuntimeConfig)
	return ret0
}

// Config indicates an expected call of Config.
func (mr *MockContainerRuntimeMockRecorder) Config() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Config", reflect.TypeOf((*MockContainerRuntime)(nil).Config))
}

// CopyToContainer mocks base method.
func (m *MockContainerRuntime) CopyToContainer(ctx context.Context, cID, dstPath, srcPath string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CopyToContainer", ctx, cID, dstPath, srcPath)
	ret0, _ := ret[0].(error)
	return ret0
}

// CopyToContainer indicates an expected call of CopyToContainer.
func (mr *MockContainerRuntimeMockRecorder) CopyToContainer(ctx, cID, dstPath, srcPath any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyToContainer", reflect.TypeOf((*MockContainerRuntime)(nil).CopyToContainer), ctx, cID, dstPath, srcPath)
}

// CreateContainer mocks base method.
func (m *MockContainerRuntime) CreateContainer(arg0 context.Context, arg1 *types.NodeConfig) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateContainer", arg0, arg1)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateContainer indicates an expected call of CreateContainer.
func (mr *MockContainerRuntimeMockRecorder) CreateContainer(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateContainer", reflect.TypeOf((*MockContainerRuntime)(nil).CreateContainer), arg0, arg1)
}

// CreateNet mocks base method.
func (m *MockContainerRuntime) CreateNet(arg0 context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateNet", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateNet indicates an expected call of CreateNet.
func (mr *MockContainerRuntimeMockRecorder) CreateNet(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNet", reflect.TypeOf((*MockContainerRuntime)(nil).CreateNet), arg0)
}

// DeleteContainer mocks base method.
func (m *MockContainerRuntime) DeleteContainer(arg0 context.Context, arg1 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteContainer", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteContainer indicates an expected call of DeleteContainer.
func (mr *MockContainerRuntimeMockRecorder) DeleteContainer(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteContainer", reflect.TypeOf((*MockContainerRuntime)(nil).DeleteContainer), arg0, arg1)
}

// DeleteNet mocks base method.
func (m *MockContainerRuntime) DeleteNet(arg0 context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNet", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteNet indicates an expected call of DeleteNet.
func (mr *MockContainerRuntimeMockRecorder) DeleteNet(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNet", reflect.TypeOf((*MockContainerRuntime)(nil).DeleteNet), arg0)
}

// Exec mocks base method.
func (m *MockContainerRuntime) Exec(ctx context.Context, cID string, execCmd *exec.ExecCmd) (*exec.ExecResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Exec", ctx, cID, execCmd)
	ret0, _ := ret[0].(*exec.ExecResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Exec indicates an expected call of Exec.
func (mr *MockContainerRuntimeMockRecorder) Exec(ctx, cID, execCmd any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Exec", reflect.TypeOf((*MockContainerRuntime)(nil).Exec), ctx, cID, execCmd)
}

// ExecNotWait mocks base method.
func (m *MockContainerRuntime) ExecNotWait(ctx context.Context, cID string, execCmd *exec.ExecCmd) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExecNotWait", ctx, cID, execCmd)
	ret0, _ := ret[0].(error)
	return ret0
}

// ExecNotWait indicates an expected call of ExecNotWait.
func (mr *MockContainerRuntimeMockRecorder) ExecNotWait(ctx, cID, execCmd any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecNotWait", reflect.TypeOf((*MockContainerRuntime)(nil).ExecNotWait), ctx, cID, execCmd)
}

// GetContainerStatus mocks base method.
func (m *MockContainerRuntime) GetContainerStatus(ctx context.Context, cID string) runtime.ContainerStatus {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetContainerStatus", ctx, cID)
	ret0, _ := ret[0].(runtime.ContainerStatus)
	return ret0
}

// GetContainerStatus indicates an expected call of GetContainerStatus.
func (mr *MockContainerRuntimeMockRecorder) GetContainerStatus(ctx, cID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContainerStatus", reflect.TypeOf((*MockContainerRuntime)(nil).GetContainerStatus), ctx, cID)
}

// GetCooCBindMounts mocks base method.
func (m *MockContainerRuntime) GetCooCBindMounts() types.Binds {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCooCBindMounts")
	ret0, _ := ret[0].(types.Binds)
	return ret0
}

// GetCooCBindMounts indicates an expected call of GetCooCBindMounts.
func (mr *MockContainerRuntimeMockRecorder) GetCooCBindMounts() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCooCBindMounts", reflect.TypeOf((*MockContainerRuntime)(nil).GetCooCBindMounts))
}

// GetHostsPath mocks base method.
func (m *MockContainerRuntime) GetHostsPath(arg0 context.Context, arg1 string) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetHostsPath", arg0, arg1)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetHostsPath indicates an expected call of GetHostsPath.
func (mr *MockContainerRuntimeMockRecorder) GetHostsPath(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHostsPath", reflect.TypeOf((*MockContainerRuntime)(nil).GetHostsPath), arg0, arg1)
}

// GetNSPath mocks base method.
func (m *MockContainerRuntime) GetNSPath(arg0 context.Context, arg1 string) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNSPath", arg0, arg1)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetNSPath indicates an expected call of GetNSPath.
func (mr *MockContainerRuntimeMockRecorder) GetNSPath(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNSPath", reflect.TypeOf((*MockContainerRuntime)(nil).GetNSPath), arg0, arg1)
}

// GetName mocks base method.
func (m *MockContainerRuntime) GetName() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetName")
	ret0, _ := ret[0].(string)
	return ret0
}

// GetName indicates an expected call of GetName.
func (mr *MockContainerRuntimeMockRecorder) GetName() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetName", reflect.TypeOf((*MockContainerRuntime)(nil).GetName))
}

// GetRuntimeSocket mocks base method.
func (m *MockContainerRuntime) GetRuntimeSocket() (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRuntimeSocket")
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRuntimeSocket indicates an expected call of GetRuntimeSocket.
func (mr *MockContainerRuntimeMockRecorder) GetRuntimeSocket() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRuntimeSocket", reflect.TypeOf((*MockContainerRuntime)(nil).GetRuntimeSocket))
}

// Init mocks base method.
func (m *MockContainerRuntime) Init(arg0 ...runtime.RuntimeOption) error {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range arg0 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Init", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// Init indicates an expected call of Init.
func (mr *MockContainerRuntimeMockRecorder) Init(arg0 ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockContainerRuntime)(nil).Init), arg0...)
}

// InspectImage mocks base method.
func (m *MockContainerRuntime) InspectImage(ctx context.Context, imageName string) (*runtime.ImageInspect, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InspectImage", ctx, imageName)
	ret0, _ := ret[0].(*runtime.ImageInspect)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InspectImage indicates an expected call of InspectImage.
func (mr *MockContainerRuntimeMockRecorder) InspectImage(ctx, imageName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InspectImage", reflect.TypeOf((*MockContainerRuntime)(nil).InspectImage), ctx, imageName)
}

// IsHealthy mocks base method.
func (m *MockContainerRuntime) IsHealthy(ctx context.Context, cID string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsHealthy", ctx, cID)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// IsHealthy indicates an expected call of IsHealthy.
func (mr *MockContainerRuntimeMockRecorder) IsHealthy(ctx, cID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsHealthy", reflect.TypeOf((*MockContainerRuntime)(nil).IsHealthy), ctx, cID)
}

// ListContainers mocks base method.
func (m *MockContainerRuntime) ListContainers(arg0 context.Context, arg1 []*types.GenericFilter) ([]runtime.GenericContainer, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListContainers", arg0, arg1)
	ret0, _ := ret[0].([]runtime.GenericContainer)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListContainers indicates an expected call of ListContainers.
func (mr *MockContainerRuntimeMockRecorder) ListContainers(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListContainers", reflect.TypeOf((*MockContainerRuntime)(nil).ListContainers), arg0, arg1)
}

// LogNonRunningContainerOutput mocks base method.
func (m *MockContainerRuntime) LogNonRunningContainerOutput(ctx context.Context, containerName string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "LogNonRunningContainerOutput", ctx, containerName)
}

// LogNonRunningContainerOutput indicates an expected call of LogNonRunningContainerOutput.
func (mr *MockContainerRuntimeMockRecorder) LogNonRunningContainerOutput(ctx, containerName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LogNonRunningContainerOutput", reflect.TypeOf((*MockContainerRuntime)(nil).LogNonRunningContainerOutput), ctx, containerName)
}

// Mgmt mocks base method.
func (m *MockContainerRuntime) Mgmt() *types.MgmtNet {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Mgmt")
	ret0, _ := ret[0].(*types.MgmtNet)
	return ret0
}

// Mgmt indicates an expected call of Mgmt.
func (mr *MockContainerRuntimeMockRecorder) Mgmt() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Mgmt", reflect.TypeOf((*MockContainerRuntime)(nil).Mgmt))
}

// PauseContainer mocks base method.
func (m *MockContainerRuntime) PauseContainer(arg0 context.Context, arg1 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PauseContainer", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// PauseContainer indicates an expected call of PauseContainer.
func (mr *MockContainerRuntimeMockRecorder) PauseContainer(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PauseContainer", reflect.TypeOf((*MockContainerRuntime)(nil).PauseContainer), arg0, arg1)
}

// PullImage mocks base method.
func (m *MockContainerRuntime) PullImage(arg0 context.Context, arg1 string, arg2 types.PullPolicyValue) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PullImage", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// PullImage indicates an expected call of PullImage.
func (mr *MockContainerRuntimeMockRecorder) PullImage(arg0, arg1, arg2 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PullImage", reflect.TypeOf((*MockContainerRuntime)(nil).PullImage), arg0, arg1, arg2)
}

// StartContainer mocks base method.
func (m *MockContainerRuntime) StartContainer(arg0 context.Context, arg1 string, arg2 runtime.Node) (any, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartContainer", arg0, arg1, arg2)
	ret0, _ := ret[0].(any)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StartContainer indicates an expected call of StartContainer.
func (mr *MockContainerRuntimeMockRecorder) StartContainer(arg0, arg1, arg2 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartContainer", reflect.TypeOf((*MockContainerRuntime)(nil).StartContainer), arg0, arg1, arg2)
}

// StopContainer mocks base method.
func (m *MockContainerRuntime) StopContainer(ctx context.Context, name string, stopSignal types.Signal) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopContainer", ctx, name, stopSignal)
	ret0, _ := ret[0].(error)
	return ret0
}

// StopContainer indicates an expected call of StopContainer.
func (mr *MockContainerRuntimeMockRecorder) StopContainer(ctx, name, stopSignal any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopContainer", reflect.TypeOf((*MockContainerRuntime)(nil).StopContainer), ctx, name, stopSignal)
}

// StreamEvents mocks base method.
func (m *MockContainerRuntime) StreamEvents(ctx context.Context, opts runtime.EventStreamOptions) (<-chan runtime.ContainerEvent, <-chan error, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StreamEvents", ctx, opts)
	ret0, _ := ret[0].(<-chan runtime.ContainerEvent)
	ret1, _ := ret[1].(<-chan error)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// StreamEvents indicates an expected call of StreamEvents.
func (mr *MockContainerRuntimeMockRecorder) StreamEvents(ctx, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StreamEvents", reflect.TypeOf((*MockContainerRuntime)(nil).StreamEvents), ctx, opts)
}

// StreamLogs mocks base method.
func (m *MockContainerRuntime) StreamLogs(ctx context.Context, containerName string) (io.ReadCloser, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StreamLogs", ctx, containerName)
	ret0, _ := ret[0].(io.ReadCloser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StreamLogs indicates an expected call of StreamLogs.
func (mr *MockContainerRuntimeMockRecorder) StreamLogs(ctx, containerName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StreamLogs", reflect.TypeOf((*MockContainerRuntime)(nil).StreamLogs), ctx, containerName)
}

// UnpauseContainer mocks base method.
func (m *MockContainerRuntime) UnpauseContainer(arg0 context.Context, arg1 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UnpauseContainer", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// UnpauseContainer indicates an expected call of UnpauseContainer.
func (mr *MockContainerRuntimeMockRecorder) UnpauseContainer(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnpauseContainer", reflect.TypeOf((*MockContainerRuntime)(nil).UnpauseContainer), arg0, arg1)
}

// WithConfig mocks base method.
func (m *MockContainerRuntime) WithConfig(arg0 *runtime.RuntimeConfig) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "WithConfig", arg0)
}

// WithConfig indicates an expected call of WithConfig.
func (mr *MockContainerRuntimeMockRecorder) WithConfig(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithConfig", reflect.TypeOf((*MockContainerRuntime)(nil).WithConfig), arg0)
}

// WithKeepMgmtNet mocks base method.
func (m *MockContainerRuntime) WithKeepMgmtNet() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "WithKeepMgmtNet")
}

// WithKeepMgmtNet indicates an expected call of WithKeepMgmtNet.
func (mr *MockContainerRuntimeMockRecorder) WithKeepMgmtNet() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithKeepMgmtNet", reflect.TypeOf((*MockContainerRuntime)(nil).WithKeepMgmtNet))
}

// WithMgmtNet mocks base method.
func (m *MockContainerRuntime) WithMgmtNet(arg0 *types.MgmtNet) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "WithMgmtNet", arg0)
}

// WithMgmtNet indicates an expected call of WithMgmtNet.
func (mr *MockContainerRuntimeMockRecorder) WithMgmtNet(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithMgmtNet", reflect.TypeOf((*MockContainerRuntime)(nil).WithMgmtNet), arg0)
}

// WriteToStdinNoWait mocks base method.
func (m *MockContainerRuntime) WriteToStdinNoWait(ctx context.Context, cID string, data []byte) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteToStdinNoWait", ctx, cID, data)
	ret0, _ := ret[0].(error)
	return ret0
}

// WriteToStdinNoWait indicates an expected call of WriteToStdinNoWait.
func (mr *MockContainerRuntimeMockRecorder) WriteToStdinNoWait(ctx, cID, data any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteToStdinNoWait", reflect.TypeOf((*MockContainerRuntime)(nil).WriteToStdinNoWait), ctx, cID, data)
}

// MockNode is a mock of Node interface.
type MockNode struct {
	ctrl     *gomock.Controller
	recorder *MockNodeMockRecorder
	isgomock struct{}
}

// MockNodeMockRecorder is the mock recorder for MockNode.
type MockNodeMockRecorder struct {
	mock *MockNode
}

// NewMockNode creates a new mock instance.
func NewMockNode(ctrl *gomock.Controller) *MockNode {
	mock := &MockNode{ctrl: ctrl}
	mock.recorder = &MockNodeMockRecorder{mock}
	return mock
}

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

// Config mocks base method.
func (m *MockNode) Config() *types.NodeConfig {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Config")
	ret0, _ := ret[0].(*types.NodeConfig)
	return ret0
}

// Config indicates an expected call of Config.
func (mr *MockNodeMockRecorder) Config() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Config", reflect.TypeOf((*MockNode)(nil).Config))
}

// GetEndpoints mocks base method.
func (m *MockNode) GetEndpoints() []links.Endpoint {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetEndpoints")
	ret0, _ := ret[0].([]links.Endpoint)
	return ret0
}

// GetEndpoints indicates an expected call of GetEndpoints.
func (mr *MockNodeMockRecorder) GetEndpoints() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEndpoints", reflect.TypeOf((*MockNode)(nil).GetEndpoints))
}
