// Code generated by MockGen. DO NOT EDIT.
// Source: gitlab.com/gitlab-org/cli/internal/commands/cluster/agent/bootstrap (interfaces: API,FluxWrapper,KubectlWrapper,Cmd)
//
// Generated by this command:
//
//	mockgen -typed -destination=./mocks_for_test.go -package=bootstrap gitlab.com/gitlab-org/cli/internal/commands/cluster/agent/bootstrap API,FluxWrapper,KubectlWrapper,Cmd
//

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

import (
	reflect "reflect"

	gitlab "gitlab.com/gitlab-org/api/client-go"
	gomock "go.uber.org/mock/gomock"
)

// MockAPI is a mock of API interface.
type MockAPI struct {
	ctrl     *gomock.Controller
	recorder *MockAPIMockRecorder
	isgomock struct{}
}

// MockAPIMockRecorder is the mock recorder for MockAPI.
type MockAPIMockRecorder struct {
	mock *MockAPI
}

// NewMockAPI creates a new mock instance.
func NewMockAPI(ctrl *gomock.Controller) *MockAPI {
	mock := &MockAPI{ctrl: ctrl}
	mock.recorder = &MockAPIMockRecorder{mock}
	return mock
}

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

// ConfigureAgent mocks base method.
func (m *MockAPI) ConfigureAgent(agent *gitlab.Agent, branch string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ConfigureAgent", agent, branch)
	ret0, _ := ret[0].(error)
	return ret0
}

// ConfigureAgent indicates an expected call of ConfigureAgent.
func (mr *MockAPIMockRecorder) ConfigureAgent(agent, branch any) *MockAPIConfigureAgentCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigureAgent", reflect.TypeOf((*MockAPI)(nil).ConfigureAgent), agent, branch)
	return &MockAPIConfigureAgentCall{Call: call}
}

// MockAPIConfigureAgentCall wrap *gomock.Call
type MockAPIConfigureAgentCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockAPIConfigureAgentCall) Return(arg0 error) *MockAPIConfigureAgentCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockAPIConfigureAgentCall) Do(f func(*gitlab.Agent, string) error) *MockAPIConfigureAgentCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockAPIConfigureAgentCall) DoAndReturn(f func(*gitlab.Agent, string) error) *MockAPIConfigureAgentCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ConfigureEnvironment mocks base method.
func (m *MockAPI) ConfigureEnvironment(agentID int64, name, kubernetesNamespace, fluxResourcePath string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ConfigureEnvironment", agentID, name, kubernetesNamespace, fluxResourcePath)
	ret0, _ := ret[0].(error)
	return ret0
}

// ConfigureEnvironment indicates an expected call of ConfigureEnvironment.
func (mr *MockAPIMockRecorder) ConfigureEnvironment(agentID, name, kubernetesNamespace, fluxResourcePath any) *MockAPIConfigureEnvironmentCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigureEnvironment", reflect.TypeOf((*MockAPI)(nil).ConfigureEnvironment), agentID, name, kubernetesNamespace, fluxResourcePath)
	return &MockAPIConfigureEnvironmentCall{Call: call}
}

// MockAPIConfigureEnvironmentCall wrap *gomock.Call
type MockAPIConfigureEnvironmentCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockAPIConfigureEnvironmentCall) Return(arg0 error) *MockAPIConfigureEnvironmentCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockAPIConfigureEnvironmentCall) Do(f func(int64, string, string, string) error) *MockAPIConfigureEnvironmentCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockAPIConfigureEnvironmentCall) DoAndReturn(f func(int64, string, string, string) error) *MockAPIConfigureEnvironmentCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// CreateAgentToken mocks base method.
func (m *MockAPI) CreateAgentToken(agentID int64) (*gitlab.AgentToken, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateAgentToken", agentID)
	ret0, _ := ret[0].(*gitlab.AgentToken)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateAgentToken indicates an expected call of CreateAgentToken.
func (mr *MockAPIMockRecorder) CreateAgentToken(agentID any) *MockAPICreateAgentTokenCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAgentToken", reflect.TypeOf((*MockAPI)(nil).CreateAgentToken), agentID)
	return &MockAPICreateAgentTokenCall{Call: call}
}

// MockAPICreateAgentTokenCall wrap *gomock.Call
type MockAPICreateAgentTokenCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockAPICreateAgentTokenCall) Return(arg0 *gitlab.AgentToken, arg1 error) *MockAPICreateAgentTokenCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockAPICreateAgentTokenCall) Do(f func(int64) (*gitlab.AgentToken, error)) *MockAPICreateAgentTokenCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockAPICreateAgentTokenCall) DoAndReturn(f func(int64) (*gitlab.AgentToken, error)) *MockAPICreateAgentTokenCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// GetAgentByName indicates an expected call of GetAgentByName.
func (mr *MockAPIMockRecorder) GetAgentByName(name any) *MockAPIGetAgentByNameCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAgentByName", reflect.TypeOf((*MockAPI)(nil).GetAgentByName), name)
	return &MockAPIGetAgentByNameCall{Call: call}
}

// MockAPIGetAgentByNameCall wrap *gomock.Call
type MockAPIGetAgentByNameCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockAPIGetAgentByNameCall) Return(arg0 *gitlab.Agent, arg1 error) *MockAPIGetAgentByNameCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockAPIGetAgentByNameCall) Do(f func(string) (*gitlab.Agent, error)) *MockAPIGetAgentByNameCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockAPIGetAgentByNameCall) DoAndReturn(f func(string) (*gitlab.Agent, error)) *MockAPIGetAgentByNameCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// GetDefaultBranch indicates an expected call of GetDefaultBranch.
func (mr *MockAPIMockRecorder) GetDefaultBranch() *MockAPIGetDefaultBranchCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDefaultBranch", reflect.TypeOf((*MockAPI)(nil).GetDefaultBranch))
	return &MockAPIGetDefaultBranchCall{Call: call}
}

// MockAPIGetDefaultBranchCall wrap *gomock.Call
type MockAPIGetDefaultBranchCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockAPIGetDefaultBranchCall) Return(arg0 string, arg1 error) *MockAPIGetDefaultBranchCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockAPIGetDefaultBranchCall) Do(f func() (string, error)) *MockAPIGetDefaultBranchCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockAPIGetDefaultBranchCall) DoAndReturn(f func() (string, error)) *MockAPIGetDefaultBranchCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// GetKASAddress indicates an expected call of GetKASAddress.
func (mr *MockAPIMockRecorder) GetKASAddress() *MockAPIGetKASAddressCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetKASAddress", reflect.TypeOf((*MockAPI)(nil).GetKASAddress))
	return &MockAPIGetKASAddressCall{Call: call}
}

// MockAPIGetKASAddressCall wrap *gomock.Call
type MockAPIGetKASAddressCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockAPIGetKASAddressCall) Return(arg0 string, arg1 error) *MockAPIGetKASAddressCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockAPIGetKASAddressCall) Do(f func() (string, error)) *MockAPIGetKASAddressCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockAPIGetKASAddressCall) DoAndReturn(f func() (string, error)) *MockAPIGetKASAddressCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// RegisterAgent indicates an expected call of RegisterAgent.
func (mr *MockAPIMockRecorder) RegisterAgent(name any) *MockAPIRegisterAgentCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterAgent", reflect.TypeOf((*MockAPI)(nil).RegisterAgent), name)
	return &MockAPIRegisterAgentCall{Call: call}
}

// MockAPIRegisterAgentCall wrap *gomock.Call
type MockAPIRegisterAgentCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockAPIRegisterAgentCall) Return(arg0 *gitlab.Agent, arg1 error) *MockAPIRegisterAgentCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockAPIRegisterAgentCall) Do(f func(string) (*gitlab.Agent, error)) *MockAPIRegisterAgentCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockAPIRegisterAgentCall) DoAndReturn(f func(string) (*gitlab.Agent, error)) *MockAPIRegisterAgentCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SyncFile mocks base method.
func (m *MockAPI) SyncFile(f file, branch string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SyncFile", f, branch)
	ret0, _ := ret[0].(error)
	return ret0
}

// SyncFile indicates an expected call of SyncFile.
func (mr *MockAPIMockRecorder) SyncFile(f, branch any) *MockAPISyncFileCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SyncFile", reflect.TypeOf((*MockAPI)(nil).SyncFile), f, branch)
	return &MockAPISyncFileCall{Call: call}
}

// MockAPISyncFileCall wrap *gomock.Call
type MockAPISyncFileCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockAPISyncFileCall) Return(arg0 error) *MockAPISyncFileCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockAPISyncFileCall) Do(f func(file, string) error) *MockAPISyncFileCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockAPISyncFileCall) DoAndReturn(f func(file, string) error) *MockAPISyncFileCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockFluxWrapper is a mock of FluxWrapper interface.
type MockFluxWrapper struct {
	ctrl     *gomock.Controller
	recorder *MockFluxWrapperMockRecorder
	isgomock struct{}
}

// MockFluxWrapperMockRecorder is the mock recorder for MockFluxWrapper.
type MockFluxWrapperMockRecorder struct {
	mock *MockFluxWrapper
}

// NewMockFluxWrapper creates a new mock instance.
func NewMockFluxWrapper(ctrl *gomock.Controller) *MockFluxWrapper {
	mock := &MockFluxWrapper{ctrl: ctrl}
	mock.recorder = &MockFluxWrapperMockRecorder{mock}
	return mock
}

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

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

// createHelmReleaseManifest indicates an expected call of createHelmReleaseManifest.
func (mr *MockFluxWrapperMockRecorder) createHelmReleaseManifest(kasAddress any) *MockFluxWrappercreateHelmReleaseManifestCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "createHelmReleaseManifest", reflect.TypeOf((*MockFluxWrapper)(nil).createHelmReleaseManifest), kasAddress)
	return &MockFluxWrappercreateHelmReleaseManifestCall{Call: call}
}

// MockFluxWrappercreateHelmReleaseManifestCall wrap *gomock.Call
type MockFluxWrappercreateHelmReleaseManifestCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockFluxWrappercreateHelmReleaseManifestCall) Return(arg0 file, arg1 error) *MockFluxWrappercreateHelmReleaseManifestCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockFluxWrappercreateHelmReleaseManifestCall) Do(f func(string) (file, error)) *MockFluxWrappercreateHelmReleaseManifestCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockFluxWrappercreateHelmReleaseManifestCall) DoAndReturn(f func(string) (file, error)) *MockFluxWrappercreateHelmReleaseManifestCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// createHelmRepositoryManifest indicates an expected call of createHelmRepositoryManifest.
func (mr *MockFluxWrapperMockRecorder) createHelmRepositoryManifest() *MockFluxWrappercreateHelmRepositoryManifestCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "createHelmRepositoryManifest", reflect.TypeOf((*MockFluxWrapper)(nil).createHelmRepositoryManifest))
	return &MockFluxWrappercreateHelmRepositoryManifestCall{Call: call}
}

// MockFluxWrappercreateHelmRepositoryManifestCall wrap *gomock.Call
type MockFluxWrappercreateHelmRepositoryManifestCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockFluxWrappercreateHelmRepositoryManifestCall) Return(arg0 file, arg1 error) *MockFluxWrappercreateHelmRepositoryManifestCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockFluxWrappercreateHelmRepositoryManifestCall) Do(f func() (file, error)) *MockFluxWrappercreateHelmRepositoryManifestCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockFluxWrappercreateHelmRepositoryManifestCall) DoAndReturn(f func() (file, error)) *MockFluxWrappercreateHelmRepositoryManifestCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// reconcile indicates an expected call of reconcile.
func (mr *MockFluxWrapperMockRecorder) reconcile() *MockFluxWrapperreconcileCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "reconcile", reflect.TypeOf((*MockFluxWrapper)(nil).reconcile))
	return &MockFluxWrapperreconcileCall{Call: call}
}

// MockFluxWrapperreconcileCall wrap *gomock.Call
type MockFluxWrapperreconcileCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockFluxWrapperreconcileCall) Return(arg0 error) *MockFluxWrapperreconcileCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockFluxWrapperreconcileCall) Do(f func() error) *MockFluxWrapperreconcileCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockFluxWrapperreconcileCall) DoAndReturn(f func() error) *MockFluxWrapperreconcileCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockKubectlWrapper is a mock of KubectlWrapper interface.
type MockKubectlWrapper struct {
	ctrl     *gomock.Controller
	recorder *MockKubectlWrapperMockRecorder
	isgomock struct{}
}

// MockKubectlWrapperMockRecorder is the mock recorder for MockKubectlWrapper.
type MockKubectlWrapperMockRecorder struct {
	mock *MockKubectlWrapper
}

// NewMockKubectlWrapper creates a new mock instance.
func NewMockKubectlWrapper(ctrl *gomock.Controller) *MockKubectlWrapper {
	mock := &MockKubectlWrapper{ctrl: ctrl}
	mock.recorder = &MockKubectlWrapperMockRecorder{mock}
	return mock
}

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

// createAgentTokenSecret mocks base method.
func (m *MockKubectlWrapper) createAgentTokenSecret(tokenID int64, token string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "createAgentTokenSecret", tokenID, token)
	ret0, _ := ret[0].(error)
	return ret0
}

// createAgentTokenSecret indicates an expected call of createAgentTokenSecret.
func (mr *MockKubectlWrapperMockRecorder) createAgentTokenSecret(tokenID, token any) *MockKubectlWrappercreateAgentTokenSecretCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "createAgentTokenSecret", reflect.TypeOf((*MockKubectlWrapper)(nil).createAgentTokenSecret), tokenID, token)
	return &MockKubectlWrappercreateAgentTokenSecretCall{Call: call}
}

// MockKubectlWrappercreateAgentTokenSecretCall wrap *gomock.Call
type MockKubectlWrappercreateAgentTokenSecretCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockKubectlWrappercreateAgentTokenSecretCall) Return(arg0 error) *MockKubectlWrappercreateAgentTokenSecretCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockKubectlWrappercreateAgentTokenSecretCall) Do(f func(int64, string) error) *MockKubectlWrappercreateAgentTokenSecretCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockKubectlWrappercreateAgentTokenSecretCall) DoAndReturn(f func(int64, string) error) *MockKubectlWrappercreateAgentTokenSecretCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockCmd is a mock of Cmd interface.
type MockCmd struct {
	ctrl     *gomock.Controller
	recorder *MockCmdMockRecorder
	isgomock struct{}
}

// MockCmdMockRecorder is the mock recorder for MockCmd.
type MockCmdMockRecorder struct {
	mock *MockCmd
}

// NewMockCmd creates a new mock instance.
func NewMockCmd(ctrl *gomock.Controller) *MockCmd {
	mock := &MockCmd{ctrl: ctrl}
	mock.recorder = &MockCmdMockRecorder{mock}
	return mock
}

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

// Run mocks base method.
func (m *MockCmd) Run(name string, arg ...string) error {
	m.ctrl.T.Helper()
	varargs := []any{name}
	for _, a := range arg {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Run", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// Run indicates an expected call of Run.
func (mr *MockCmdMockRecorder) Run(name any, arg ...any) *MockCmdRunCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{name}, arg...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockCmd)(nil).Run), varargs...)
	return &MockCmdRunCall{Call: call}
}

// MockCmdRunCall wrap *gomock.Call
type MockCmdRunCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockCmdRunCall) Return(arg0 error) *MockCmdRunCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockCmdRunCall) Do(f func(string, ...string) error) *MockCmdRunCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCmdRunCall) DoAndReturn(f func(string, ...string) error) *MockCmdRunCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// RunWithOutput mocks base method.
func (m *MockCmd) RunWithOutput(name string, arg ...string) ([]byte, error) {
	m.ctrl.T.Helper()
	varargs := []any{name}
	for _, a := range arg {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RunWithOutput", varargs...)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RunWithOutput indicates an expected call of RunWithOutput.
func (mr *MockCmdMockRecorder) RunWithOutput(name any, arg ...any) *MockCmdRunWithOutputCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{name}, arg...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunWithOutput", reflect.TypeOf((*MockCmd)(nil).RunWithOutput), varargs...)
	return &MockCmdRunWithOutputCall{Call: call}
}

// MockCmdRunWithOutputCall wrap *gomock.Call
type MockCmdRunWithOutputCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockCmdRunWithOutputCall) Return(arg0 []byte, arg1 error) *MockCmdRunWithOutputCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockCmdRunWithOutputCall) Do(f func(string, ...string) ([]byte, error)) *MockCmdRunWithOutputCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCmdRunWithOutputCall) DoAndReturn(f func(string, ...string) ([]byte, error)) *MockCmdRunWithOutputCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}
