// Code generated by moq; DO NOT EDIT.
// github.com/matryer/moq

package mocks

import (
	"github.com/schmitthub/clawker/internal/config"
	"github.com/schmitthub/clawker/internal/storage"
	"sync"
)

// Ensure, that ConfigMock does implement config.Config.
// If this is not the case, regenerate this file with moq.
var _ config.Config = &ConfigMock{}

// ConfigMock is a mock implementation of config.Config.
//
//	func TestSomethingThatUsesConfig(t *testing.T) {
//
//		// make and configure a mocked config.Config
//		mockedConfig := &ConfigMock{
//			BridgePIDFilePathFunc: func(containerID string) (string, error) {
//				panic("mock out the BridgePIDFilePath method")
//			},
//			BridgesSubdirFunc: func() (string, error) {
//				panic("mock out the BridgesSubdir method")
//			},
//			BuildSubdirFunc: func() (string, error) {
//				panic("mock out the BuildSubdir method")
//			},
//			CPIPLastOctetFunc: func() byte {
//				panic("mock out the CPIPLastOctet method")
//			},
//			ClawkerIgnoreNameFunc: func() string {
//				panic("mock out the ClawkerIgnoreName method")
//			},
//			ClawkerNetworkFunc: func() string {
//				panic("mock out the ClawkerNetwork method")
//			},
//			ConfigDirEnvVarFunc: func() string {
//				panic("mock out the ConfigDirEnvVar method")
//			},
//			ContainerGIDFunc: func() int {
//				panic("mock out the ContainerGID method")
//			},
//			ContainerUIDFunc: func() int {
//				panic("mock out the ContainerUID method")
//			},
//			CoreDNSHealthHostPortFunc: func() int {
//				panic("mock out the CoreDNSHealthHostPort method")
//			},
//			CoreDNSHealthPathFunc: func() string {
//				panic("mock out the CoreDNSHealthPath method")
//			},
//			CoreDNSIPLastOctetFunc: func() byte {
//				panic("mock out the CoreDNSIPLastOctet method")
//			},
//			DataDirEnvVarFunc: func() string {
//				panic("mock out the DataDirEnvVar method")
//			},
//			DockerfilesSubdirFunc: func() (string, error) {
//				panic("mock out the DockerfilesSubdir method")
//			},
//			DomainFunc: func() string {
//				panic("mock out the Domain method")
//			},
//			EgressRulesFileNameFunc: func() string {
//				panic("mock out the EgressRulesFileName method")
//			},
//			EngineLabelPrefixFunc: func() string {
//				panic("mock out the EngineLabelPrefix method")
//			},
//			EngineManagedLabelFunc: func() string {
//				panic("mock out the EngineManagedLabel method")
//			},
//			EnvoyEgressPortFunc: func() int {
//				panic("mock out the EnvoyEgressPort method")
//			},
//			EnvoyHealthHostPortFunc: func() int {
//				panic("mock out the EnvoyHealthHostPort method")
//			},
//			EnvoyHealthPortFunc: func() int {
//				panic("mock out the EnvoyHealthPort method")
//			},
//			EnvoyIPLastOctetFunc: func() byte {
//				panic("mock out the EnvoyIPLastOctet method")
//			},
//			EnvoyTCPPortBaseFunc: func() int {
//				panic("mock out the EnvoyTCPPortBase method")
//			},
//			FirewallCertSubdirFunc: func() (string, error) {
//				panic("mock out the FirewallCertSubdir method")
//			},
//			FirewallDataSubdirFunc: func() (string, error) {
//				panic("mock out the FirewallDataSubdir method")
//			},
//			GetProjectIgnoreFileFunc: func() (string, error) {
//				panic("mock out the GetProjectIgnoreFile method")
//			},
//			GetProjectRootFunc: func() (string, error) {
//				panic("mock out the GetProjectRoot method")
//			},
//			HostProxyConfigFunc: func() config.HostProxyConfig {
//				panic("mock out the HostProxyConfig method")
//			},
//			HostProxyLogFilePathFunc: func() (string, error) {
//				panic("mock out the HostProxyLogFilePath method")
//			},
//			HostProxyPIDFilePathFunc: func() (string, error) {
//				panic("mock out the HostProxyPIDFilePath method")
//			},
//			LabelAgentFunc: func() string {
//				panic("mock out the LabelAgent method")
//			},
//			LabelBaseImageFunc: func() string {
//				panic("mock out the LabelBaseImage method")
//			},
//			LabelCreatedFunc: func() string {
//				panic("mock out the LabelCreated method")
//			},
//			LabelDomainFunc: func() string {
//				panic("mock out the LabelDomain method")
//			},
//			LabelE2ETestFunc: func() string {
//				panic("mock out the LabelE2ETest method")
//			},
//			LabelFlavorFunc: func() string {
//				panic("mock out the LabelFlavor method")
//			},
//			LabelImageFunc: func() string {
//				panic("mock out the LabelImage method")
//			},
//			LabelManagedFunc: func() string {
//				panic("mock out the LabelManaged method")
//			},
//			LabelPrefixFunc: func() string {
//				panic("mock out the LabelPrefix method")
//			},
//			LabelProjectFunc: func() string {
//				panic("mock out the LabelProject method")
//			},
//			LabelPurposeFunc: func() string {
//				panic("mock out the LabelPurpose method")
//			},
//			LabelTestFunc: func() string {
//				panic("mock out the LabelTest method")
//			},
//			LabelTestNameFunc: func() string {
//				panic("mock out the LabelTestName method")
//			},
//			LabelVersionFunc: func() string {
//				panic("mock out the LabelVersion method")
//			},
//			LabelWorkdirFunc: func() string {
//				panic("mock out the LabelWorkdir method")
//			},
//			LoggingConfigFunc: func() config.LoggingConfig {
//				panic("mock out the LoggingConfig method")
//			},
//			LogsSubdirFunc: func() (string, error) {
//				panic("mock out the LogsSubdir method")
//			},
//			ManagedLabelValueFunc: func() string {
//				panic("mock out the ManagedLabelValue method")
//			},
//			MonitorSubdirFunc: func() (string, error) {
//				panic("mock out the MonitorSubdir method")
//			},
//			MonitoringConfigFunc: func() config.MonitoringConfig {
//				panic("mock out the MonitoringConfig method")
//			},
//			OpenSearchDashboardsURLFunc: func() string {
//				panic("mock out the OpenSearchDashboardsURL method")
//			},
//			OpenSearchURLFunc: func() string {
//				panic("mock out the OpenSearchURL method")
//			},
//			OtelCollectorURLFunc: func() string {
//				panic("mock out the OtelCollectorURL method")
//			},
//			PidsSubdirFunc: func() (string, error) {
//				panic("mock out the PidsSubdir method")
//			},
//			ProjectFunc: func() *config.Project {
//				panic("mock out the Project method")
//			},
//			ProjectConfigFileNameFunc: func() string {
//				panic("mock out the ProjectConfigFileName method")
//			},
//			ProjectRegistryFileNameFunc: func() string {
//				panic("mock out the ProjectRegistryFileName method")
//			},
//			ProjectStoreFunc: func() *storage.Store[config.Project] {
//				panic("mock out the ProjectStore method")
//			},
//			PrometheusURLFunc: func() string {
//				panic("mock out the PrometheusURL method")
//			},
//			PurposeAgentFunc: func() string {
//				panic("mock out the PurposeAgent method")
//			},
//			PurposeFirewallFunc: func() string {
//				panic("mock out the PurposeFirewall method")
//			},
//			PurposeMonitoringFunc: func() string {
//				panic("mock out the PurposeMonitoring method")
//			},
//			RequiredFirewallDomainsFunc: func() []string {
//				panic("mock out the RequiredFirewallDomains method")
//			},
//			RequiredFirewallRulesFunc: func() []config.EgressRule {
//				panic("mock out the RequiredFirewallRules method")
//			},
//			SettingsFunc: func() *config.Settings {
//				panic("mock out the Settings method")
//			},
//			SettingsFileNameFunc: func() string {
//				panic("mock out the SettingsFileName method")
//			},
//			SettingsStoreFunc: func() *storage.Store[config.Settings] {
//				panic("mock out the SettingsStore method")
//			},
//			ShareSubdirFunc: func() (string, error) {
//				panic("mock out the ShareSubdir method")
//			},
//			StateDirEnvVarFunc: func() string {
//				panic("mock out the StateDirEnvVar method")
//			},
//			TestRepoDirEnvVarFunc: func() string {
//				panic("mock out the TestRepoDirEnvVar method")
//			},
//			WorktreesSubdirFunc: func() (string, error) {
//				panic("mock out the WorktreesSubdir method")
//			},
//		}
//
//		// use mockedConfig in code that requires config.Config
//		// and then make assertions.
//
//	}
type ConfigMock struct {
	// BridgePIDFilePathFunc mocks the BridgePIDFilePath method.
	BridgePIDFilePathFunc func(containerID string) (string, error)

	// BridgesSubdirFunc mocks the BridgesSubdir method.
	BridgesSubdirFunc func() (string, error)

	// BuildSubdirFunc mocks the BuildSubdir method.
	BuildSubdirFunc func() (string, error)

	// CPIPLastOctetFunc mocks the CPIPLastOctet method.
	CPIPLastOctetFunc func() byte

	// ClawkerIgnoreNameFunc mocks the ClawkerIgnoreName method.
	ClawkerIgnoreNameFunc func() string

	// ClawkerNetworkFunc mocks the ClawkerNetwork method.
	ClawkerNetworkFunc func() string

	// ConfigDirEnvVarFunc mocks the ConfigDirEnvVar method.
	ConfigDirEnvVarFunc func() string

	// ContainerGIDFunc mocks the ContainerGID method.
	ContainerGIDFunc func() int

	// ContainerUIDFunc mocks the ContainerUID method.
	ContainerUIDFunc func() int

	// CoreDNSHealthHostPortFunc mocks the CoreDNSHealthHostPort method.
	CoreDNSHealthHostPortFunc func() int

	// CoreDNSHealthPathFunc mocks the CoreDNSHealthPath method.
	CoreDNSHealthPathFunc func() string

	// CoreDNSIPLastOctetFunc mocks the CoreDNSIPLastOctet method.
	CoreDNSIPLastOctetFunc func() byte

	// DataDirEnvVarFunc mocks the DataDirEnvVar method.
	DataDirEnvVarFunc func() string

	// DockerfilesSubdirFunc mocks the DockerfilesSubdir method.
	DockerfilesSubdirFunc func() (string, error)

	// DomainFunc mocks the Domain method.
	DomainFunc func() string

	// EgressRulesFileNameFunc mocks the EgressRulesFileName method.
	EgressRulesFileNameFunc func() string

	// EngineLabelPrefixFunc mocks the EngineLabelPrefix method.
	EngineLabelPrefixFunc func() string

	// EngineManagedLabelFunc mocks the EngineManagedLabel method.
	EngineManagedLabelFunc func() string

	// EnvoyEgressPortFunc mocks the EnvoyEgressPort method.
	EnvoyEgressPortFunc func() int

	// EnvoyHealthHostPortFunc mocks the EnvoyHealthHostPort method.
	EnvoyHealthHostPortFunc func() int

	// EnvoyHealthPortFunc mocks the EnvoyHealthPort method.
	EnvoyHealthPortFunc func() int

	// EnvoyIPLastOctetFunc mocks the EnvoyIPLastOctet method.
	EnvoyIPLastOctetFunc func() byte

	// EnvoyTCPPortBaseFunc mocks the EnvoyTCPPortBase method.
	EnvoyTCPPortBaseFunc func() int

	// FirewallCertSubdirFunc mocks the FirewallCertSubdir method.
	FirewallCertSubdirFunc func() (string, error)

	// FirewallDataSubdirFunc mocks the FirewallDataSubdir method.
	FirewallDataSubdirFunc func() (string, error)

	// GetProjectIgnoreFileFunc mocks the GetProjectIgnoreFile method.
	GetProjectIgnoreFileFunc func() (string, error)

	// GetProjectRootFunc mocks the GetProjectRoot method.
	GetProjectRootFunc func() (string, error)

	// HostProxyConfigFunc mocks the HostProxyConfig method.
	HostProxyConfigFunc func() config.HostProxyConfig

	// HostProxyLogFilePathFunc mocks the HostProxyLogFilePath method.
	HostProxyLogFilePathFunc func() (string, error)

	// HostProxyPIDFilePathFunc mocks the HostProxyPIDFilePath method.
	HostProxyPIDFilePathFunc func() (string, error)

	// LabelAgentFunc mocks the LabelAgent method.
	LabelAgentFunc func() string

	// LabelBaseImageFunc mocks the LabelBaseImage method.
	LabelBaseImageFunc func() string

	// LabelCreatedFunc mocks the LabelCreated method.
	LabelCreatedFunc func() string

	// LabelDomainFunc mocks the LabelDomain method.
	LabelDomainFunc func() string

	// LabelE2ETestFunc mocks the LabelE2ETest method.
	LabelE2ETestFunc func() string

	// LabelFlavorFunc mocks the LabelFlavor method.
	LabelFlavorFunc func() string

	// LabelImageFunc mocks the LabelImage method.
	LabelImageFunc func() string

	// LabelManagedFunc mocks the LabelManaged method.
	LabelManagedFunc func() string

	// LabelPrefixFunc mocks the LabelPrefix method.
	LabelPrefixFunc func() string

	// LabelProjectFunc mocks the LabelProject method.
	LabelProjectFunc func() string

	// LabelPurposeFunc mocks the LabelPurpose method.
	LabelPurposeFunc func() string

	// LabelTestFunc mocks the LabelTest method.
	LabelTestFunc func() string

	// LabelTestNameFunc mocks the LabelTestName method.
	LabelTestNameFunc func() string

	// LabelVersionFunc mocks the LabelVersion method.
	LabelVersionFunc func() string

	// LabelWorkdirFunc mocks the LabelWorkdir method.
	LabelWorkdirFunc func() string

	// LoggingConfigFunc mocks the LoggingConfig method.
	LoggingConfigFunc func() config.LoggingConfig

	// LogsSubdirFunc mocks the LogsSubdir method.
	LogsSubdirFunc func() (string, error)

	// ManagedLabelValueFunc mocks the ManagedLabelValue method.
	ManagedLabelValueFunc func() string

	// MonitorSubdirFunc mocks the MonitorSubdir method.
	MonitorSubdirFunc func() (string, error)

	// MonitoringConfigFunc mocks the MonitoringConfig method.
	MonitoringConfigFunc func() config.MonitoringConfig

	// OpenSearchDashboardsURLFunc mocks the OpenSearchDashboardsURL method.
	OpenSearchDashboardsURLFunc func() string

	// OpenSearchURLFunc mocks the OpenSearchURL method.
	OpenSearchURLFunc func() string

	// OtelCollectorURLFunc mocks the OtelCollectorURL method.
	OtelCollectorURLFunc func() string

	// PidsSubdirFunc mocks the PidsSubdir method.
	PidsSubdirFunc func() (string, error)

	// ProjectFunc mocks the Project method.
	ProjectFunc func() *config.Project

	// ProjectConfigFileNameFunc mocks the ProjectConfigFileName method.
	ProjectConfigFileNameFunc func() string

	// ProjectRegistryFileNameFunc mocks the ProjectRegistryFileName method.
	ProjectRegistryFileNameFunc func() string

	// ProjectStoreFunc mocks the ProjectStore method.
	ProjectStoreFunc func() *storage.Store[config.Project]

	// PrometheusURLFunc mocks the PrometheusURL method.
	PrometheusURLFunc func() string

	// PurposeAgentFunc mocks the PurposeAgent method.
	PurposeAgentFunc func() string

	// PurposeFirewallFunc mocks the PurposeFirewall method.
	PurposeFirewallFunc func() string

	// PurposeMonitoringFunc mocks the PurposeMonitoring method.
	PurposeMonitoringFunc func() string

	// RequiredFirewallDomainsFunc mocks the RequiredFirewallDomains method.
	RequiredFirewallDomainsFunc func() []string

	// RequiredFirewallRulesFunc mocks the RequiredFirewallRules method.
	RequiredFirewallRulesFunc func() []config.EgressRule

	// SettingsFunc mocks the Settings method.
	SettingsFunc func() *config.Settings

	// SettingsFileNameFunc mocks the SettingsFileName method.
	SettingsFileNameFunc func() string

	// SettingsStoreFunc mocks the SettingsStore method.
	SettingsStoreFunc func() *storage.Store[config.Settings]

	// ShareSubdirFunc mocks the ShareSubdir method.
	ShareSubdirFunc func() (string, error)

	// StateDirEnvVarFunc mocks the StateDirEnvVar method.
	StateDirEnvVarFunc func() string

	// TestRepoDirEnvVarFunc mocks the TestRepoDirEnvVar method.
	TestRepoDirEnvVarFunc func() string

	// WorktreesSubdirFunc mocks the WorktreesSubdir method.
	WorktreesSubdirFunc func() (string, error)

	// calls tracks calls to the methods.
	calls struct {
		// BridgePIDFilePath holds details about calls to the BridgePIDFilePath method.
		BridgePIDFilePath []struct {
			// ContainerID is the containerID argument value.
			ContainerID string
		}
		// BridgesSubdir holds details about calls to the BridgesSubdir method.
		BridgesSubdir []struct {
		}
		// BuildSubdir holds details about calls to the BuildSubdir method.
		BuildSubdir []struct {
		}
		// CPIPLastOctet holds details about calls to the CPIPLastOctet method.
		CPIPLastOctet []struct {
		}
		// ClawkerIgnoreName holds details about calls to the ClawkerIgnoreName method.
		ClawkerIgnoreName []struct {
		}
		// ClawkerNetwork holds details about calls to the ClawkerNetwork method.
		ClawkerNetwork []struct {
		}
		// ConfigDirEnvVar holds details about calls to the ConfigDirEnvVar method.
		ConfigDirEnvVar []struct {
		}
		// ContainerGID holds details about calls to the ContainerGID method.
		ContainerGID []struct {
		}
		// ContainerUID holds details about calls to the ContainerUID method.
		ContainerUID []struct {
		}
		// CoreDNSHealthHostPort holds details about calls to the CoreDNSHealthHostPort method.
		CoreDNSHealthHostPort []struct {
		}
		// CoreDNSHealthPath holds details about calls to the CoreDNSHealthPath method.
		CoreDNSHealthPath []struct {
		}
		// CoreDNSIPLastOctet holds details about calls to the CoreDNSIPLastOctet method.
		CoreDNSIPLastOctet []struct {
		}
		// DataDirEnvVar holds details about calls to the DataDirEnvVar method.
		DataDirEnvVar []struct {
		}
		// DockerfilesSubdir holds details about calls to the DockerfilesSubdir method.
		DockerfilesSubdir []struct {
		}
		// Domain holds details about calls to the Domain method.
		Domain []struct {
		}
		// EgressRulesFileName holds details about calls to the EgressRulesFileName method.
		EgressRulesFileName []struct {
		}
		// EngineLabelPrefix holds details about calls to the EngineLabelPrefix method.
		EngineLabelPrefix []struct {
		}
		// EngineManagedLabel holds details about calls to the EngineManagedLabel method.
		EngineManagedLabel []struct {
		}
		// EnvoyEgressPort holds details about calls to the EnvoyEgressPort method.
		EnvoyEgressPort []struct {
		}
		// EnvoyHealthHostPort holds details about calls to the EnvoyHealthHostPort method.
		EnvoyHealthHostPort []struct {
		}
		// EnvoyHealthPort holds details about calls to the EnvoyHealthPort method.
		EnvoyHealthPort []struct {
		}
		// EnvoyIPLastOctet holds details about calls to the EnvoyIPLastOctet method.
		EnvoyIPLastOctet []struct {
		}
		// EnvoyTCPPortBase holds details about calls to the EnvoyTCPPortBase method.
		EnvoyTCPPortBase []struct {
		}
		// FirewallCertSubdir holds details about calls to the FirewallCertSubdir method.
		FirewallCertSubdir []struct {
		}
		// FirewallDataSubdir holds details about calls to the FirewallDataSubdir method.
		FirewallDataSubdir []struct {
		}
		// GetProjectIgnoreFile holds details about calls to the GetProjectIgnoreFile method.
		GetProjectIgnoreFile []struct {
		}
		// GetProjectRoot holds details about calls to the GetProjectRoot method.
		GetProjectRoot []struct {
		}
		// HostProxyConfig holds details about calls to the HostProxyConfig method.
		HostProxyConfig []struct {
		}
		// HostProxyLogFilePath holds details about calls to the HostProxyLogFilePath method.
		HostProxyLogFilePath []struct {
		}
		// HostProxyPIDFilePath holds details about calls to the HostProxyPIDFilePath method.
		HostProxyPIDFilePath []struct {
		}
		// LabelAgent holds details about calls to the LabelAgent method.
		LabelAgent []struct {
		}
		// LabelBaseImage holds details about calls to the LabelBaseImage method.
		LabelBaseImage []struct {
		}
		// LabelCreated holds details about calls to the LabelCreated method.
		LabelCreated []struct {
		}
		// LabelDomain holds details about calls to the LabelDomain method.
		LabelDomain []struct {
		}
		// LabelE2ETest holds details about calls to the LabelE2ETest method.
		LabelE2ETest []struct {
		}
		// LabelFlavor holds details about calls to the LabelFlavor method.
		LabelFlavor []struct {
		}
		// LabelImage holds details about calls to the LabelImage method.
		LabelImage []struct {
		}
		// LabelManaged holds details about calls to the LabelManaged method.
		LabelManaged []struct {
		}
		// LabelPrefix holds details about calls to the LabelPrefix method.
		LabelPrefix []struct {
		}
		// LabelProject holds details about calls to the LabelProject method.
		LabelProject []struct {
		}
		// LabelPurpose holds details about calls to the LabelPurpose method.
		LabelPurpose []struct {
		}
		// LabelTest holds details about calls to the LabelTest method.
		LabelTest []struct {
		}
		// LabelTestName holds details about calls to the LabelTestName method.
		LabelTestName []struct {
		}
		// LabelVersion holds details about calls to the LabelVersion method.
		LabelVersion []struct {
		}
		// LabelWorkdir holds details about calls to the LabelWorkdir method.
		LabelWorkdir []struct {
		}
		// LoggingConfig holds details about calls to the LoggingConfig method.
		LoggingConfig []struct {
		}
		// LogsSubdir holds details about calls to the LogsSubdir method.
		LogsSubdir []struct {
		}
		// ManagedLabelValue holds details about calls to the ManagedLabelValue method.
		ManagedLabelValue []struct {
		}
		// MonitorSubdir holds details about calls to the MonitorSubdir method.
		MonitorSubdir []struct {
		}
		// MonitoringConfig holds details about calls to the MonitoringConfig method.
		MonitoringConfig []struct {
		}
		// OpenSearchDashboardsURL holds details about calls to the OpenSearchDashboardsURL method.
		OpenSearchDashboardsURL []struct {
		}
		// OpenSearchURL holds details about calls to the OpenSearchURL method.
		OpenSearchURL []struct {
		}
		// OtelCollectorURL holds details about calls to the OtelCollectorURL method.
		OtelCollectorURL []struct {
		}
		// PidsSubdir holds details about calls to the PidsSubdir method.
		PidsSubdir []struct {
		}
		// Project holds details about calls to the Project method.
		Project []struct {
		}
		// ProjectConfigFileName holds details about calls to the ProjectConfigFileName method.
		ProjectConfigFileName []struct {
		}
		// ProjectRegistryFileName holds details about calls to the ProjectRegistryFileName method.
		ProjectRegistryFileName []struct {
		}
		// ProjectStore holds details about calls to the ProjectStore method.
		ProjectStore []struct {
		}
		// PrometheusURL holds details about calls to the PrometheusURL method.
		PrometheusURL []struct {
		}
		// PurposeAgent holds details about calls to the PurposeAgent method.
		PurposeAgent []struct {
		}
		// PurposeFirewall holds details about calls to the PurposeFirewall method.
		PurposeFirewall []struct {
		}
		// PurposeMonitoring holds details about calls to the PurposeMonitoring method.
		PurposeMonitoring []struct {
		}
		// RequiredFirewallDomains holds details about calls to the RequiredFirewallDomains method.
		RequiredFirewallDomains []struct {
		}
		// RequiredFirewallRules holds details about calls to the RequiredFirewallRules method.
		RequiredFirewallRules []struct {
		}
		// Settings holds details about calls to the Settings method.
		Settings []struct {
		}
		// SettingsFileName holds details about calls to the SettingsFileName method.
		SettingsFileName []struct {
		}
		// SettingsStore holds details about calls to the SettingsStore method.
		SettingsStore []struct {
		}
		// ShareSubdir holds details about calls to the ShareSubdir method.
		ShareSubdir []struct {
		}
		// StateDirEnvVar holds details about calls to the StateDirEnvVar method.
		StateDirEnvVar []struct {
		}
		// TestRepoDirEnvVar holds details about calls to the TestRepoDirEnvVar method.
		TestRepoDirEnvVar []struct {
		}
		// WorktreesSubdir holds details about calls to the WorktreesSubdir method.
		WorktreesSubdir []struct {
		}
	}
	lockBridgePIDFilePath       sync.RWMutex
	lockBridgesSubdir           sync.RWMutex
	lockBuildSubdir             sync.RWMutex
	lockCPIPLastOctet           sync.RWMutex
	lockClawkerIgnoreName       sync.RWMutex
	lockClawkerNetwork          sync.RWMutex
	lockConfigDirEnvVar         sync.RWMutex
	lockContainerGID            sync.RWMutex
	lockContainerUID            sync.RWMutex
	lockCoreDNSHealthHostPort   sync.RWMutex
	lockCoreDNSHealthPath       sync.RWMutex
	lockCoreDNSIPLastOctet      sync.RWMutex
	lockDataDirEnvVar           sync.RWMutex
	lockDockerfilesSubdir       sync.RWMutex
	lockDomain                  sync.RWMutex
	lockEgressRulesFileName     sync.RWMutex
	lockEngineLabelPrefix       sync.RWMutex
	lockEngineManagedLabel      sync.RWMutex
	lockEnvoyEgressPort         sync.RWMutex
	lockEnvoyHealthHostPort     sync.RWMutex
	lockEnvoyHealthPort         sync.RWMutex
	lockEnvoyIPLastOctet        sync.RWMutex
	lockEnvoyTCPPortBase        sync.RWMutex
	lockFirewallCertSubdir      sync.RWMutex
	lockFirewallDataSubdir      sync.RWMutex
	lockGetProjectIgnoreFile    sync.RWMutex
	lockGetProjectRoot          sync.RWMutex
	lockHostProxyConfig         sync.RWMutex
	lockHostProxyLogFilePath    sync.RWMutex
	lockHostProxyPIDFilePath    sync.RWMutex
	lockLabelAgent              sync.RWMutex
	lockLabelBaseImage          sync.RWMutex
	lockLabelCreated            sync.RWMutex
	lockLabelDomain             sync.RWMutex
	lockLabelE2ETest            sync.RWMutex
	lockLabelFlavor             sync.RWMutex
	lockLabelImage              sync.RWMutex
	lockLabelManaged            sync.RWMutex
	lockLabelPrefix             sync.RWMutex
	lockLabelProject            sync.RWMutex
	lockLabelPurpose            sync.RWMutex
	lockLabelTest               sync.RWMutex
	lockLabelTestName           sync.RWMutex
	lockLabelVersion            sync.RWMutex
	lockLabelWorkdir            sync.RWMutex
	lockLoggingConfig           sync.RWMutex
	lockLogsSubdir              sync.RWMutex
	lockManagedLabelValue       sync.RWMutex
	lockMonitorSubdir           sync.RWMutex
	lockMonitoringConfig        sync.RWMutex
	lockOpenSearchDashboardsURL sync.RWMutex
	lockOpenSearchURL           sync.RWMutex
	lockOtelCollectorURL        sync.RWMutex
	lockPidsSubdir              sync.RWMutex
	lockProject                 sync.RWMutex
	lockProjectConfigFileName   sync.RWMutex
	lockProjectRegistryFileName sync.RWMutex
	lockProjectStore            sync.RWMutex
	lockPrometheusURL           sync.RWMutex
	lockPurposeAgent            sync.RWMutex
	lockPurposeFirewall         sync.RWMutex
	lockPurposeMonitoring       sync.RWMutex
	lockRequiredFirewallDomains sync.RWMutex
	lockRequiredFirewallRules   sync.RWMutex
	lockSettings                sync.RWMutex
	lockSettingsFileName        sync.RWMutex
	lockSettingsStore           sync.RWMutex
	lockShareSubdir             sync.RWMutex
	lockStateDirEnvVar          sync.RWMutex
	lockTestRepoDirEnvVar       sync.RWMutex
	lockWorktreesSubdir         sync.RWMutex
}

// BridgePIDFilePath calls BridgePIDFilePathFunc.
func (mock *ConfigMock) BridgePIDFilePath(containerID string) (string, error) {
	if mock.BridgePIDFilePathFunc == nil {
		panic("ConfigMock.BridgePIDFilePathFunc: method is nil but Config.BridgePIDFilePath was just called")
	}
	callInfo := struct {
		ContainerID string
	}{
		ContainerID: containerID,
	}
	mock.lockBridgePIDFilePath.Lock()
	mock.calls.BridgePIDFilePath = append(mock.calls.BridgePIDFilePath, callInfo)
	mock.lockBridgePIDFilePath.Unlock()
	return mock.BridgePIDFilePathFunc(containerID)
}

// BridgePIDFilePathCalls gets all the calls that were made to BridgePIDFilePath.
// Check the length with:
//
//	len(mockedConfig.BridgePIDFilePathCalls())
func (mock *ConfigMock) BridgePIDFilePathCalls() []struct {
	ContainerID string
} {
	var calls []struct {
		ContainerID string
	}
	mock.lockBridgePIDFilePath.RLock()
	calls = mock.calls.BridgePIDFilePath
	mock.lockBridgePIDFilePath.RUnlock()
	return calls
}

// BridgesSubdir calls BridgesSubdirFunc.
func (mock *ConfigMock) BridgesSubdir() (string, error) {
	if mock.BridgesSubdirFunc == nil {
		panic("ConfigMock.BridgesSubdirFunc: method is nil but Config.BridgesSubdir was just called")
	}
	callInfo := struct {
	}{}
	mock.lockBridgesSubdir.Lock()
	mock.calls.BridgesSubdir = append(mock.calls.BridgesSubdir, callInfo)
	mock.lockBridgesSubdir.Unlock()
	return mock.BridgesSubdirFunc()
}

// BridgesSubdirCalls gets all the calls that were made to BridgesSubdir.
// Check the length with:
//
//	len(mockedConfig.BridgesSubdirCalls())
func (mock *ConfigMock) BridgesSubdirCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockBridgesSubdir.RLock()
	calls = mock.calls.BridgesSubdir
	mock.lockBridgesSubdir.RUnlock()
	return calls
}

// BuildSubdir calls BuildSubdirFunc.
func (mock *ConfigMock) BuildSubdir() (string, error) {
	if mock.BuildSubdirFunc == nil {
		panic("ConfigMock.BuildSubdirFunc: method is nil but Config.BuildSubdir was just called")
	}
	callInfo := struct {
	}{}
	mock.lockBuildSubdir.Lock()
	mock.calls.BuildSubdir = append(mock.calls.BuildSubdir, callInfo)
	mock.lockBuildSubdir.Unlock()
	return mock.BuildSubdirFunc()
}

// BuildSubdirCalls gets all the calls that were made to BuildSubdir.
// Check the length with:
//
//	len(mockedConfig.BuildSubdirCalls())
func (mock *ConfigMock) BuildSubdirCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockBuildSubdir.RLock()
	calls = mock.calls.BuildSubdir
	mock.lockBuildSubdir.RUnlock()
	return calls
}

// CPIPLastOctet calls CPIPLastOctetFunc.
func (mock *ConfigMock) CPIPLastOctet() byte {
	if mock.CPIPLastOctetFunc == nil {
		panic("ConfigMock.CPIPLastOctetFunc: method is nil but Config.CPIPLastOctet was just called")
	}
	callInfo := struct {
	}{}
	mock.lockCPIPLastOctet.Lock()
	mock.calls.CPIPLastOctet = append(mock.calls.CPIPLastOctet, callInfo)
	mock.lockCPIPLastOctet.Unlock()
	return mock.CPIPLastOctetFunc()
}

// CPIPLastOctetCalls gets all the calls that were made to CPIPLastOctet.
// Check the length with:
//
//	len(mockedConfig.CPIPLastOctetCalls())
func (mock *ConfigMock) CPIPLastOctetCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockCPIPLastOctet.RLock()
	calls = mock.calls.CPIPLastOctet
	mock.lockCPIPLastOctet.RUnlock()
	return calls
}

// ClawkerIgnoreName calls ClawkerIgnoreNameFunc.
func (mock *ConfigMock) ClawkerIgnoreName() string {
	if mock.ClawkerIgnoreNameFunc == nil {
		panic("ConfigMock.ClawkerIgnoreNameFunc: method is nil but Config.ClawkerIgnoreName was just called")
	}
	callInfo := struct {
	}{}
	mock.lockClawkerIgnoreName.Lock()
	mock.calls.ClawkerIgnoreName = append(mock.calls.ClawkerIgnoreName, callInfo)
	mock.lockClawkerIgnoreName.Unlock()
	return mock.ClawkerIgnoreNameFunc()
}

// ClawkerIgnoreNameCalls gets all the calls that were made to ClawkerIgnoreName.
// Check the length with:
//
//	len(mockedConfig.ClawkerIgnoreNameCalls())
func (mock *ConfigMock) ClawkerIgnoreNameCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockClawkerIgnoreName.RLock()
	calls = mock.calls.ClawkerIgnoreName
	mock.lockClawkerIgnoreName.RUnlock()
	return calls
}

// ClawkerNetwork calls ClawkerNetworkFunc.
func (mock *ConfigMock) ClawkerNetwork() string {
	if mock.ClawkerNetworkFunc == nil {
		panic("ConfigMock.ClawkerNetworkFunc: method is nil but Config.ClawkerNetwork was just called")
	}
	callInfo := struct {
	}{}
	mock.lockClawkerNetwork.Lock()
	mock.calls.ClawkerNetwork = append(mock.calls.ClawkerNetwork, callInfo)
	mock.lockClawkerNetwork.Unlock()
	return mock.ClawkerNetworkFunc()
}

// ClawkerNetworkCalls gets all the calls that were made to ClawkerNetwork.
// Check the length with:
//
//	len(mockedConfig.ClawkerNetworkCalls())
func (mock *ConfigMock) ClawkerNetworkCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockClawkerNetwork.RLock()
	calls = mock.calls.ClawkerNetwork
	mock.lockClawkerNetwork.RUnlock()
	return calls
}

// ConfigDirEnvVar calls ConfigDirEnvVarFunc.
func (mock *ConfigMock) ConfigDirEnvVar() string {
	if mock.ConfigDirEnvVarFunc == nil {
		panic("ConfigMock.ConfigDirEnvVarFunc: method is nil but Config.ConfigDirEnvVar was just called")
	}
	callInfo := struct {
	}{}
	mock.lockConfigDirEnvVar.Lock()
	mock.calls.ConfigDirEnvVar = append(mock.calls.ConfigDirEnvVar, callInfo)
	mock.lockConfigDirEnvVar.Unlock()
	return mock.ConfigDirEnvVarFunc()
}

// ConfigDirEnvVarCalls gets all the calls that were made to ConfigDirEnvVar.
// Check the length with:
//
//	len(mockedConfig.ConfigDirEnvVarCalls())
func (mock *ConfigMock) ConfigDirEnvVarCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockConfigDirEnvVar.RLock()
	calls = mock.calls.ConfigDirEnvVar
	mock.lockConfigDirEnvVar.RUnlock()
	return calls
}

// ContainerGID calls ContainerGIDFunc.
func (mock *ConfigMock) ContainerGID() int {
	if mock.ContainerGIDFunc == nil {
		panic("ConfigMock.ContainerGIDFunc: method is nil but Config.ContainerGID was just called")
	}
	callInfo := struct {
	}{}
	mock.lockContainerGID.Lock()
	mock.calls.ContainerGID = append(mock.calls.ContainerGID, callInfo)
	mock.lockContainerGID.Unlock()
	return mock.ContainerGIDFunc()
}

// ContainerGIDCalls gets all the calls that were made to ContainerGID.
// Check the length with:
//
//	len(mockedConfig.ContainerGIDCalls())
func (mock *ConfigMock) ContainerGIDCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockContainerGID.RLock()
	calls = mock.calls.ContainerGID
	mock.lockContainerGID.RUnlock()
	return calls
}

// ContainerUID calls ContainerUIDFunc.
func (mock *ConfigMock) ContainerUID() int {
	if mock.ContainerUIDFunc == nil {
		panic("ConfigMock.ContainerUIDFunc: method is nil but Config.ContainerUID was just called")
	}
	callInfo := struct {
	}{}
	mock.lockContainerUID.Lock()
	mock.calls.ContainerUID = append(mock.calls.ContainerUID, callInfo)
	mock.lockContainerUID.Unlock()
	return mock.ContainerUIDFunc()
}

// ContainerUIDCalls gets all the calls that were made to ContainerUID.
// Check the length with:
//
//	len(mockedConfig.ContainerUIDCalls())
func (mock *ConfigMock) ContainerUIDCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockContainerUID.RLock()
	calls = mock.calls.ContainerUID
	mock.lockContainerUID.RUnlock()
	return calls
}

// CoreDNSHealthHostPort calls CoreDNSHealthHostPortFunc.
func (mock *ConfigMock) CoreDNSHealthHostPort() int {
	if mock.CoreDNSHealthHostPortFunc == nil {
		panic("ConfigMock.CoreDNSHealthHostPortFunc: method is nil but Config.CoreDNSHealthHostPort was just called")
	}
	callInfo := struct {
	}{}
	mock.lockCoreDNSHealthHostPort.Lock()
	mock.calls.CoreDNSHealthHostPort = append(mock.calls.CoreDNSHealthHostPort, callInfo)
	mock.lockCoreDNSHealthHostPort.Unlock()
	return mock.CoreDNSHealthHostPortFunc()
}

// CoreDNSHealthHostPortCalls gets all the calls that were made to CoreDNSHealthHostPort.
// Check the length with:
//
//	len(mockedConfig.CoreDNSHealthHostPortCalls())
func (mock *ConfigMock) CoreDNSHealthHostPortCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockCoreDNSHealthHostPort.RLock()
	calls = mock.calls.CoreDNSHealthHostPort
	mock.lockCoreDNSHealthHostPort.RUnlock()
	return calls
}

// CoreDNSHealthPath calls CoreDNSHealthPathFunc.
func (mock *ConfigMock) CoreDNSHealthPath() string {
	if mock.CoreDNSHealthPathFunc == nil {
		panic("ConfigMock.CoreDNSHealthPathFunc: method is nil but Config.CoreDNSHealthPath was just called")
	}
	callInfo := struct {
	}{}
	mock.lockCoreDNSHealthPath.Lock()
	mock.calls.CoreDNSHealthPath = append(mock.calls.CoreDNSHealthPath, callInfo)
	mock.lockCoreDNSHealthPath.Unlock()
	return mock.CoreDNSHealthPathFunc()
}

// CoreDNSHealthPathCalls gets all the calls that were made to CoreDNSHealthPath.
// Check the length with:
//
//	len(mockedConfig.CoreDNSHealthPathCalls())
func (mock *ConfigMock) CoreDNSHealthPathCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockCoreDNSHealthPath.RLock()
	calls = mock.calls.CoreDNSHealthPath
	mock.lockCoreDNSHealthPath.RUnlock()
	return calls
}

// CoreDNSIPLastOctet calls CoreDNSIPLastOctetFunc.
func (mock *ConfigMock) CoreDNSIPLastOctet() byte {
	if mock.CoreDNSIPLastOctetFunc == nil {
		panic("ConfigMock.CoreDNSIPLastOctetFunc: method is nil but Config.CoreDNSIPLastOctet was just called")
	}
	callInfo := struct {
	}{}
	mock.lockCoreDNSIPLastOctet.Lock()
	mock.calls.CoreDNSIPLastOctet = append(mock.calls.CoreDNSIPLastOctet, callInfo)
	mock.lockCoreDNSIPLastOctet.Unlock()
	return mock.CoreDNSIPLastOctetFunc()
}

// CoreDNSIPLastOctetCalls gets all the calls that were made to CoreDNSIPLastOctet.
// Check the length with:
//
//	len(mockedConfig.CoreDNSIPLastOctetCalls())
func (mock *ConfigMock) CoreDNSIPLastOctetCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockCoreDNSIPLastOctet.RLock()
	calls = mock.calls.CoreDNSIPLastOctet
	mock.lockCoreDNSIPLastOctet.RUnlock()
	return calls
}

// DataDirEnvVar calls DataDirEnvVarFunc.
func (mock *ConfigMock) DataDirEnvVar() string {
	if mock.DataDirEnvVarFunc == nil {
		panic("ConfigMock.DataDirEnvVarFunc: method is nil but Config.DataDirEnvVar was just called")
	}
	callInfo := struct {
	}{}
	mock.lockDataDirEnvVar.Lock()
	mock.calls.DataDirEnvVar = append(mock.calls.DataDirEnvVar, callInfo)
	mock.lockDataDirEnvVar.Unlock()
	return mock.DataDirEnvVarFunc()
}

// DataDirEnvVarCalls gets all the calls that were made to DataDirEnvVar.
// Check the length with:
//
//	len(mockedConfig.DataDirEnvVarCalls())
func (mock *ConfigMock) DataDirEnvVarCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockDataDirEnvVar.RLock()
	calls = mock.calls.DataDirEnvVar
	mock.lockDataDirEnvVar.RUnlock()
	return calls
}

// DockerfilesSubdir calls DockerfilesSubdirFunc.
func (mock *ConfigMock) DockerfilesSubdir() (string, error) {
	if mock.DockerfilesSubdirFunc == nil {
		panic("ConfigMock.DockerfilesSubdirFunc: method is nil but Config.DockerfilesSubdir was just called")
	}
	callInfo := struct {
	}{}
	mock.lockDockerfilesSubdir.Lock()
	mock.calls.DockerfilesSubdir = append(mock.calls.DockerfilesSubdir, callInfo)
	mock.lockDockerfilesSubdir.Unlock()
	return mock.DockerfilesSubdirFunc()
}

// DockerfilesSubdirCalls gets all the calls that were made to DockerfilesSubdir.
// Check the length with:
//
//	len(mockedConfig.DockerfilesSubdirCalls())
func (mock *ConfigMock) DockerfilesSubdirCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockDockerfilesSubdir.RLock()
	calls = mock.calls.DockerfilesSubdir
	mock.lockDockerfilesSubdir.RUnlock()
	return calls
}

// Domain calls DomainFunc.
func (mock *ConfigMock) Domain() string {
	if mock.DomainFunc == nil {
		panic("ConfigMock.DomainFunc: method is nil but Config.Domain was just called")
	}
	callInfo := struct {
	}{}
	mock.lockDomain.Lock()
	mock.calls.Domain = append(mock.calls.Domain, callInfo)
	mock.lockDomain.Unlock()
	return mock.DomainFunc()
}

// DomainCalls gets all the calls that were made to Domain.
// Check the length with:
//
//	len(mockedConfig.DomainCalls())
func (mock *ConfigMock) DomainCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockDomain.RLock()
	calls = mock.calls.Domain
	mock.lockDomain.RUnlock()
	return calls
}

// EgressRulesFileName calls EgressRulesFileNameFunc.
func (mock *ConfigMock) EgressRulesFileName() string {
	if mock.EgressRulesFileNameFunc == nil {
		panic("ConfigMock.EgressRulesFileNameFunc: method is nil but Config.EgressRulesFileName was just called")
	}
	callInfo := struct {
	}{}
	mock.lockEgressRulesFileName.Lock()
	mock.calls.EgressRulesFileName = append(mock.calls.EgressRulesFileName, callInfo)
	mock.lockEgressRulesFileName.Unlock()
	return mock.EgressRulesFileNameFunc()
}

// EgressRulesFileNameCalls gets all the calls that were made to EgressRulesFileName.
// Check the length with:
//
//	len(mockedConfig.EgressRulesFileNameCalls())
func (mock *ConfigMock) EgressRulesFileNameCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockEgressRulesFileName.RLock()
	calls = mock.calls.EgressRulesFileName
	mock.lockEgressRulesFileName.RUnlock()
	return calls
}

// EngineLabelPrefix calls EngineLabelPrefixFunc.
func (mock *ConfigMock) EngineLabelPrefix() string {
	if mock.EngineLabelPrefixFunc == nil {
		panic("ConfigMock.EngineLabelPrefixFunc: method is nil but Config.EngineLabelPrefix was just called")
	}
	callInfo := struct {
	}{}
	mock.lockEngineLabelPrefix.Lock()
	mock.calls.EngineLabelPrefix = append(mock.calls.EngineLabelPrefix, callInfo)
	mock.lockEngineLabelPrefix.Unlock()
	return mock.EngineLabelPrefixFunc()
}

// EngineLabelPrefixCalls gets all the calls that were made to EngineLabelPrefix.
// Check the length with:
//
//	len(mockedConfig.EngineLabelPrefixCalls())
func (mock *ConfigMock) EngineLabelPrefixCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockEngineLabelPrefix.RLock()
	calls = mock.calls.EngineLabelPrefix
	mock.lockEngineLabelPrefix.RUnlock()
	return calls
}

// EngineManagedLabel calls EngineManagedLabelFunc.
func (mock *ConfigMock) EngineManagedLabel() string {
	if mock.EngineManagedLabelFunc == nil {
		panic("ConfigMock.EngineManagedLabelFunc: method is nil but Config.EngineManagedLabel was just called")
	}
	callInfo := struct {
	}{}
	mock.lockEngineManagedLabel.Lock()
	mock.calls.EngineManagedLabel = append(mock.calls.EngineManagedLabel, callInfo)
	mock.lockEngineManagedLabel.Unlock()
	return mock.EngineManagedLabelFunc()
}

// EngineManagedLabelCalls gets all the calls that were made to EngineManagedLabel.
// Check the length with:
//
//	len(mockedConfig.EngineManagedLabelCalls())
func (mock *ConfigMock) EngineManagedLabelCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockEngineManagedLabel.RLock()
	calls = mock.calls.EngineManagedLabel
	mock.lockEngineManagedLabel.RUnlock()
	return calls
}

// EnvoyEgressPort calls EnvoyEgressPortFunc.
func (mock *ConfigMock) EnvoyEgressPort() int {
	if mock.EnvoyEgressPortFunc == nil {
		panic("ConfigMock.EnvoyEgressPortFunc: method is nil but Config.EnvoyEgressPort was just called")
	}
	callInfo := struct {
	}{}
	mock.lockEnvoyEgressPort.Lock()
	mock.calls.EnvoyEgressPort = append(mock.calls.EnvoyEgressPort, callInfo)
	mock.lockEnvoyEgressPort.Unlock()
	return mock.EnvoyEgressPortFunc()
}

// EnvoyEgressPortCalls gets all the calls that were made to EnvoyEgressPort.
// Check the length with:
//
//	len(mockedConfig.EnvoyEgressPortCalls())
func (mock *ConfigMock) EnvoyEgressPortCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockEnvoyEgressPort.RLock()
	calls = mock.calls.EnvoyEgressPort
	mock.lockEnvoyEgressPort.RUnlock()
	return calls
}

// EnvoyHealthHostPort calls EnvoyHealthHostPortFunc.
func (mock *ConfigMock) EnvoyHealthHostPort() int {
	if mock.EnvoyHealthHostPortFunc == nil {
		panic("ConfigMock.EnvoyHealthHostPortFunc: method is nil but Config.EnvoyHealthHostPort was just called")
	}
	callInfo := struct {
	}{}
	mock.lockEnvoyHealthHostPort.Lock()
	mock.calls.EnvoyHealthHostPort = append(mock.calls.EnvoyHealthHostPort, callInfo)
	mock.lockEnvoyHealthHostPort.Unlock()
	return mock.EnvoyHealthHostPortFunc()
}

// EnvoyHealthHostPortCalls gets all the calls that were made to EnvoyHealthHostPort.
// Check the length with:
//
//	len(mockedConfig.EnvoyHealthHostPortCalls())
func (mock *ConfigMock) EnvoyHealthHostPortCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockEnvoyHealthHostPort.RLock()
	calls = mock.calls.EnvoyHealthHostPort
	mock.lockEnvoyHealthHostPort.RUnlock()
	return calls
}

// EnvoyHealthPort calls EnvoyHealthPortFunc.
func (mock *ConfigMock) EnvoyHealthPort() int {
	if mock.EnvoyHealthPortFunc == nil {
		panic("ConfigMock.EnvoyHealthPortFunc: method is nil but Config.EnvoyHealthPort was just called")
	}
	callInfo := struct {
	}{}
	mock.lockEnvoyHealthPort.Lock()
	mock.calls.EnvoyHealthPort = append(mock.calls.EnvoyHealthPort, callInfo)
	mock.lockEnvoyHealthPort.Unlock()
	return mock.EnvoyHealthPortFunc()
}

// EnvoyHealthPortCalls gets all the calls that were made to EnvoyHealthPort.
// Check the length with:
//
//	len(mockedConfig.EnvoyHealthPortCalls())
func (mock *ConfigMock) EnvoyHealthPortCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockEnvoyHealthPort.RLock()
	calls = mock.calls.EnvoyHealthPort
	mock.lockEnvoyHealthPort.RUnlock()
	return calls
}

// EnvoyIPLastOctet calls EnvoyIPLastOctetFunc.
func (mock *ConfigMock) EnvoyIPLastOctet() byte {
	if mock.EnvoyIPLastOctetFunc == nil {
		panic("ConfigMock.EnvoyIPLastOctetFunc: method is nil but Config.EnvoyIPLastOctet was just called")
	}
	callInfo := struct {
	}{}
	mock.lockEnvoyIPLastOctet.Lock()
	mock.calls.EnvoyIPLastOctet = append(mock.calls.EnvoyIPLastOctet, callInfo)
	mock.lockEnvoyIPLastOctet.Unlock()
	return mock.EnvoyIPLastOctetFunc()
}

// EnvoyIPLastOctetCalls gets all the calls that were made to EnvoyIPLastOctet.
// Check the length with:
//
//	len(mockedConfig.EnvoyIPLastOctetCalls())
func (mock *ConfigMock) EnvoyIPLastOctetCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockEnvoyIPLastOctet.RLock()
	calls = mock.calls.EnvoyIPLastOctet
	mock.lockEnvoyIPLastOctet.RUnlock()
	return calls
}

// EnvoyTCPPortBase calls EnvoyTCPPortBaseFunc.
func (mock *ConfigMock) EnvoyTCPPortBase() int {
	if mock.EnvoyTCPPortBaseFunc == nil {
		panic("ConfigMock.EnvoyTCPPortBaseFunc: method is nil but Config.EnvoyTCPPortBase was just called")
	}
	callInfo := struct {
	}{}
	mock.lockEnvoyTCPPortBase.Lock()
	mock.calls.EnvoyTCPPortBase = append(mock.calls.EnvoyTCPPortBase, callInfo)
	mock.lockEnvoyTCPPortBase.Unlock()
	return mock.EnvoyTCPPortBaseFunc()
}

// EnvoyTCPPortBaseCalls gets all the calls that were made to EnvoyTCPPortBase.
// Check the length with:
//
//	len(mockedConfig.EnvoyTCPPortBaseCalls())
func (mock *ConfigMock) EnvoyTCPPortBaseCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockEnvoyTCPPortBase.RLock()
	calls = mock.calls.EnvoyTCPPortBase
	mock.lockEnvoyTCPPortBase.RUnlock()
	return calls
}

// FirewallCertSubdir calls FirewallCertSubdirFunc.
func (mock *ConfigMock) FirewallCertSubdir() (string, error) {
	if mock.FirewallCertSubdirFunc == nil {
		panic("ConfigMock.FirewallCertSubdirFunc: method is nil but Config.FirewallCertSubdir was just called")
	}
	callInfo := struct {
	}{}
	mock.lockFirewallCertSubdir.Lock()
	mock.calls.FirewallCertSubdir = append(mock.calls.FirewallCertSubdir, callInfo)
	mock.lockFirewallCertSubdir.Unlock()
	return mock.FirewallCertSubdirFunc()
}

// FirewallCertSubdirCalls gets all the calls that were made to FirewallCertSubdir.
// Check the length with:
//
//	len(mockedConfig.FirewallCertSubdirCalls())
func (mock *ConfigMock) FirewallCertSubdirCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockFirewallCertSubdir.RLock()
	calls = mock.calls.FirewallCertSubdir
	mock.lockFirewallCertSubdir.RUnlock()
	return calls
}

// FirewallDataSubdir calls FirewallDataSubdirFunc.
func (mock *ConfigMock) FirewallDataSubdir() (string, error) {
	if mock.FirewallDataSubdirFunc == nil {
		panic("ConfigMock.FirewallDataSubdirFunc: method is nil but Config.FirewallDataSubdir was just called")
	}
	callInfo := struct {
	}{}
	mock.lockFirewallDataSubdir.Lock()
	mock.calls.FirewallDataSubdir = append(mock.calls.FirewallDataSubdir, callInfo)
	mock.lockFirewallDataSubdir.Unlock()
	return mock.FirewallDataSubdirFunc()
}

// FirewallDataSubdirCalls gets all the calls that were made to FirewallDataSubdir.
// Check the length with:
//
//	len(mockedConfig.FirewallDataSubdirCalls())
func (mock *ConfigMock) FirewallDataSubdirCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockFirewallDataSubdir.RLock()
	calls = mock.calls.FirewallDataSubdir
	mock.lockFirewallDataSubdir.RUnlock()
	return calls
}

// GetProjectIgnoreFile calls GetProjectIgnoreFileFunc.
func (mock *ConfigMock) GetProjectIgnoreFile() (string, error) {
	if mock.GetProjectIgnoreFileFunc == nil {
		panic("ConfigMock.GetProjectIgnoreFileFunc: method is nil but Config.GetProjectIgnoreFile was just called")
	}
	callInfo := struct {
	}{}
	mock.lockGetProjectIgnoreFile.Lock()
	mock.calls.GetProjectIgnoreFile = append(mock.calls.GetProjectIgnoreFile, callInfo)
	mock.lockGetProjectIgnoreFile.Unlock()
	return mock.GetProjectIgnoreFileFunc()
}

// GetProjectIgnoreFileCalls gets all the calls that were made to GetProjectIgnoreFile.
// Check the length with:
//
//	len(mockedConfig.GetProjectIgnoreFileCalls())
func (mock *ConfigMock) GetProjectIgnoreFileCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetProjectIgnoreFile.RLock()
	calls = mock.calls.GetProjectIgnoreFile
	mock.lockGetProjectIgnoreFile.RUnlock()
	return calls
}

// GetProjectRoot calls GetProjectRootFunc.
func (mock *ConfigMock) GetProjectRoot() (string, error) {
	if mock.GetProjectRootFunc == nil {
		panic("ConfigMock.GetProjectRootFunc: method is nil but Config.GetProjectRoot was just called")
	}
	callInfo := struct {
	}{}
	mock.lockGetProjectRoot.Lock()
	mock.calls.GetProjectRoot = append(mock.calls.GetProjectRoot, callInfo)
	mock.lockGetProjectRoot.Unlock()
	return mock.GetProjectRootFunc()
}

// GetProjectRootCalls gets all the calls that were made to GetProjectRoot.
// Check the length with:
//
//	len(mockedConfig.GetProjectRootCalls())
func (mock *ConfigMock) GetProjectRootCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetProjectRoot.RLock()
	calls = mock.calls.GetProjectRoot
	mock.lockGetProjectRoot.RUnlock()
	return calls
}

// HostProxyConfig calls HostProxyConfigFunc.
func (mock *ConfigMock) HostProxyConfig() config.HostProxyConfig {
	if mock.HostProxyConfigFunc == nil {
		panic("ConfigMock.HostProxyConfigFunc: method is nil but Config.HostProxyConfig was just called")
	}
	callInfo := struct {
	}{}
	mock.lockHostProxyConfig.Lock()
	mock.calls.HostProxyConfig = append(mock.calls.HostProxyConfig, callInfo)
	mock.lockHostProxyConfig.Unlock()
	return mock.HostProxyConfigFunc()
}

// HostProxyConfigCalls gets all the calls that were made to HostProxyConfig.
// Check the length with:
//
//	len(mockedConfig.HostProxyConfigCalls())
func (mock *ConfigMock) HostProxyConfigCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockHostProxyConfig.RLock()
	calls = mock.calls.HostProxyConfig
	mock.lockHostProxyConfig.RUnlock()
	return calls
}

// HostProxyLogFilePath calls HostProxyLogFilePathFunc.
func (mock *ConfigMock) HostProxyLogFilePath() (string, error) {
	if mock.HostProxyLogFilePathFunc == nil {
		panic("ConfigMock.HostProxyLogFilePathFunc: method is nil but Config.HostProxyLogFilePath was just called")
	}
	callInfo := struct {
	}{}
	mock.lockHostProxyLogFilePath.Lock()
	mock.calls.HostProxyLogFilePath = append(mock.calls.HostProxyLogFilePath, callInfo)
	mock.lockHostProxyLogFilePath.Unlock()
	return mock.HostProxyLogFilePathFunc()
}

// HostProxyLogFilePathCalls gets all the calls that were made to HostProxyLogFilePath.
// Check the length with:
//
//	len(mockedConfig.HostProxyLogFilePathCalls())
func (mock *ConfigMock) HostProxyLogFilePathCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockHostProxyLogFilePath.RLock()
	calls = mock.calls.HostProxyLogFilePath
	mock.lockHostProxyLogFilePath.RUnlock()
	return calls
}

// HostProxyPIDFilePath calls HostProxyPIDFilePathFunc.
func (mock *ConfigMock) HostProxyPIDFilePath() (string, error) {
	if mock.HostProxyPIDFilePathFunc == nil {
		panic("ConfigMock.HostProxyPIDFilePathFunc: method is nil but Config.HostProxyPIDFilePath was just called")
	}
	callInfo := struct {
	}{}
	mock.lockHostProxyPIDFilePath.Lock()
	mock.calls.HostProxyPIDFilePath = append(mock.calls.HostProxyPIDFilePath, callInfo)
	mock.lockHostProxyPIDFilePath.Unlock()
	return mock.HostProxyPIDFilePathFunc()
}

// HostProxyPIDFilePathCalls gets all the calls that were made to HostProxyPIDFilePath.
// Check the length with:
//
//	len(mockedConfig.HostProxyPIDFilePathCalls())
func (mock *ConfigMock) HostProxyPIDFilePathCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockHostProxyPIDFilePath.RLock()
	calls = mock.calls.HostProxyPIDFilePath
	mock.lockHostProxyPIDFilePath.RUnlock()
	return calls
}

// LabelAgent calls LabelAgentFunc.
func (mock *ConfigMock) LabelAgent() string {
	if mock.LabelAgentFunc == nil {
		panic("ConfigMock.LabelAgentFunc: method is nil but Config.LabelAgent was just called")
	}
	callInfo := struct {
	}{}
	mock.lockLabelAgent.Lock()
	mock.calls.LabelAgent = append(mock.calls.LabelAgent, callInfo)
	mock.lockLabelAgent.Unlock()
	return mock.LabelAgentFunc()
}

// LabelAgentCalls gets all the calls that were made to LabelAgent.
// Check the length with:
//
//	len(mockedConfig.LabelAgentCalls())
func (mock *ConfigMock) LabelAgentCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockLabelAgent.RLock()
	calls = mock.calls.LabelAgent
	mock.lockLabelAgent.RUnlock()
	return calls
}

// LabelBaseImage calls LabelBaseImageFunc.
func (mock *ConfigMock) LabelBaseImage() string {
	if mock.LabelBaseImageFunc == nil {
		panic("ConfigMock.LabelBaseImageFunc: method is nil but Config.LabelBaseImage was just called")
	}
	callInfo := struct {
	}{}
	mock.lockLabelBaseImage.Lock()
	mock.calls.LabelBaseImage = append(mock.calls.LabelBaseImage, callInfo)
	mock.lockLabelBaseImage.Unlock()
	return mock.LabelBaseImageFunc()
}

// LabelBaseImageCalls gets all the calls that were made to LabelBaseImage.
// Check the length with:
//
//	len(mockedConfig.LabelBaseImageCalls())
func (mock *ConfigMock) LabelBaseImageCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockLabelBaseImage.RLock()
	calls = mock.calls.LabelBaseImage
	mock.lockLabelBaseImage.RUnlock()
	return calls
}

// LabelCreated calls LabelCreatedFunc.
func (mock *ConfigMock) LabelCreated() string {
	if mock.LabelCreatedFunc == nil {
		panic("ConfigMock.LabelCreatedFunc: method is nil but Config.LabelCreated was just called")
	}
	callInfo := struct {
	}{}
	mock.lockLabelCreated.Lock()
	mock.calls.LabelCreated = append(mock.calls.LabelCreated, callInfo)
	mock.lockLabelCreated.Unlock()
	return mock.LabelCreatedFunc()
}

// LabelCreatedCalls gets all the calls that were made to LabelCreated.
// Check the length with:
//
//	len(mockedConfig.LabelCreatedCalls())
func (mock *ConfigMock) LabelCreatedCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockLabelCreated.RLock()
	calls = mock.calls.LabelCreated
	mock.lockLabelCreated.RUnlock()
	return calls
}

// LabelDomain calls LabelDomainFunc.
func (mock *ConfigMock) LabelDomain() string {
	if mock.LabelDomainFunc == nil {
		panic("ConfigMock.LabelDomainFunc: method is nil but Config.LabelDomain was just called")
	}
	callInfo := struct {
	}{}
	mock.lockLabelDomain.Lock()
	mock.calls.LabelDomain = append(mock.calls.LabelDomain, callInfo)
	mock.lockLabelDomain.Unlock()
	return mock.LabelDomainFunc()
}

// LabelDomainCalls gets all the calls that were made to LabelDomain.
// Check the length with:
//
//	len(mockedConfig.LabelDomainCalls())
func (mock *ConfigMock) LabelDomainCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockLabelDomain.RLock()
	calls = mock.calls.LabelDomain
	mock.lockLabelDomain.RUnlock()
	return calls
}

// LabelE2ETest calls LabelE2ETestFunc.
func (mock *ConfigMock) LabelE2ETest() string {
	if mock.LabelE2ETestFunc == nil {
		panic("ConfigMock.LabelE2ETestFunc: method is nil but Config.LabelE2ETest was just called")
	}
	callInfo := struct {
	}{}
	mock.lockLabelE2ETest.Lock()
	mock.calls.LabelE2ETest = append(mock.calls.LabelE2ETest, callInfo)
	mock.lockLabelE2ETest.Unlock()
	return mock.LabelE2ETestFunc()
}

// LabelE2ETestCalls gets all the calls that were made to LabelE2ETest.
// Check the length with:
//
//	len(mockedConfig.LabelE2ETestCalls())
func (mock *ConfigMock) LabelE2ETestCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockLabelE2ETest.RLock()
	calls = mock.calls.LabelE2ETest
	mock.lockLabelE2ETest.RUnlock()
	return calls
}

// LabelFlavor calls LabelFlavorFunc.
func (mock *ConfigMock) LabelFlavor() string {
	if mock.LabelFlavorFunc == nil {
		panic("ConfigMock.LabelFlavorFunc: method is nil but Config.LabelFlavor was just called")
	}
	callInfo := struct {
	}{}
	mock.lockLabelFlavor.Lock()
	mock.calls.LabelFlavor = append(mock.calls.LabelFlavor, callInfo)
	mock.lockLabelFlavor.Unlock()
	return mock.LabelFlavorFunc()
}

// LabelFlavorCalls gets all the calls that were made to LabelFlavor.
// Check the length with:
//
//	len(mockedConfig.LabelFlavorCalls())
func (mock *ConfigMock) LabelFlavorCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockLabelFlavor.RLock()
	calls = mock.calls.LabelFlavor
	mock.lockLabelFlavor.RUnlock()
	return calls
}

// LabelImage calls LabelImageFunc.
func (mock *ConfigMock) LabelImage() string {
	if mock.LabelImageFunc == nil {
		panic("ConfigMock.LabelImageFunc: method is nil but Config.LabelImage was just called")
	}
	callInfo := struct {
	}{}
	mock.lockLabelImage.Lock()
	mock.calls.LabelImage = append(mock.calls.LabelImage, callInfo)
	mock.lockLabelImage.Unlock()
	return mock.LabelImageFunc()
}

// LabelImageCalls gets all the calls that were made to LabelImage.
// Check the length with:
//
//	len(mockedConfig.LabelImageCalls())
func (mock *ConfigMock) LabelImageCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockLabelImage.RLock()
	calls = mock.calls.LabelImage
	mock.lockLabelImage.RUnlock()
	return calls
}

// LabelManaged calls LabelManagedFunc.
func (mock *ConfigMock) LabelManaged() string {
	if mock.LabelManagedFunc == nil {
		panic("ConfigMock.LabelManagedFunc: method is nil but Config.LabelManaged was just called")
	}
	callInfo := struct {
	}{}
	mock.lockLabelManaged.Lock()
	mock.calls.LabelManaged = append(mock.calls.LabelManaged, callInfo)
	mock.lockLabelManaged.Unlock()
	return mock.LabelManagedFunc()
}

// LabelManagedCalls gets all the calls that were made to LabelManaged.
// Check the length with:
//
//	len(mockedConfig.LabelManagedCalls())
func (mock *ConfigMock) LabelManagedCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockLabelManaged.RLock()
	calls = mock.calls.LabelManaged
	mock.lockLabelManaged.RUnlock()
	return calls
}

// LabelPrefix calls LabelPrefixFunc.
func (mock *ConfigMock) LabelPrefix() string {
	if mock.LabelPrefixFunc == nil {
		panic("ConfigMock.LabelPrefixFunc: method is nil but Config.LabelPrefix was just called")
	}
	callInfo := struct {
	}{}
	mock.lockLabelPrefix.Lock()
	mock.calls.LabelPrefix = append(mock.calls.LabelPrefix, callInfo)
	mock.lockLabelPrefix.Unlock()
	return mock.LabelPrefixFunc()
}

// LabelPrefixCalls gets all the calls that were made to LabelPrefix.
// Check the length with:
//
//	len(mockedConfig.LabelPrefixCalls())
func (mock *ConfigMock) LabelPrefixCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockLabelPrefix.RLock()
	calls = mock.calls.LabelPrefix
	mock.lockLabelPrefix.RUnlock()
	return calls
}

// LabelProject calls LabelProjectFunc.
func (mock *ConfigMock) LabelProject() string {
	if mock.LabelProjectFunc == nil {
		panic("ConfigMock.LabelProjectFunc: method is nil but Config.LabelProject was just called")
	}
	callInfo := struct {
	}{}
	mock.lockLabelProject.Lock()
	mock.calls.LabelProject = append(mock.calls.LabelProject, callInfo)
	mock.lockLabelProject.Unlock()
	return mock.LabelProjectFunc()
}

// LabelProjectCalls gets all the calls that were made to LabelProject.
// Check the length with:
//
//	len(mockedConfig.LabelProjectCalls())
func (mock *ConfigMock) LabelProjectCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockLabelProject.RLock()
	calls = mock.calls.LabelProject
	mock.lockLabelProject.RUnlock()
	return calls
}

// LabelPurpose calls LabelPurposeFunc.
func (mock *ConfigMock) LabelPurpose() string {
	if mock.LabelPurposeFunc == nil {
		panic("ConfigMock.LabelPurposeFunc: method is nil but Config.LabelPurpose was just called")
	}
	callInfo := struct {
	}{}
	mock.lockLabelPurpose.Lock()
	mock.calls.LabelPurpose = append(mock.calls.LabelPurpose, callInfo)
	mock.lockLabelPurpose.Unlock()
	return mock.LabelPurposeFunc()
}

// LabelPurposeCalls gets all the calls that were made to LabelPurpose.
// Check the length with:
//
//	len(mockedConfig.LabelPurposeCalls())
func (mock *ConfigMock) LabelPurposeCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockLabelPurpose.RLock()
	calls = mock.calls.LabelPurpose
	mock.lockLabelPurpose.RUnlock()
	return calls
}

// LabelTest calls LabelTestFunc.
func (mock *ConfigMock) LabelTest() string {
	if mock.LabelTestFunc == nil {
		panic("ConfigMock.LabelTestFunc: method is nil but Config.LabelTest was just called")
	}
	callInfo := struct {
	}{}
	mock.lockLabelTest.Lock()
	mock.calls.LabelTest = append(mock.calls.LabelTest, callInfo)
	mock.lockLabelTest.Unlock()
	return mock.LabelTestFunc()
}

// LabelTestCalls gets all the calls that were made to LabelTest.
// Check the length with:
//
//	len(mockedConfig.LabelTestCalls())
func (mock *ConfigMock) LabelTestCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockLabelTest.RLock()
	calls = mock.calls.LabelTest
	mock.lockLabelTest.RUnlock()
	return calls
}

// LabelTestName calls LabelTestNameFunc.
func (mock *ConfigMock) LabelTestName() string {
	if mock.LabelTestNameFunc == nil {
		panic("ConfigMock.LabelTestNameFunc: method is nil but Config.LabelTestName was just called")
	}
	callInfo := struct {
	}{}
	mock.lockLabelTestName.Lock()
	mock.calls.LabelTestName = append(mock.calls.LabelTestName, callInfo)
	mock.lockLabelTestName.Unlock()
	return mock.LabelTestNameFunc()
}

// LabelTestNameCalls gets all the calls that were made to LabelTestName.
// Check the length with:
//
//	len(mockedConfig.LabelTestNameCalls())
func (mock *ConfigMock) LabelTestNameCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockLabelTestName.RLock()
	calls = mock.calls.LabelTestName
	mock.lockLabelTestName.RUnlock()
	return calls
}

// LabelVersion calls LabelVersionFunc.
func (mock *ConfigMock) LabelVersion() string {
	if mock.LabelVersionFunc == nil {
		panic("ConfigMock.LabelVersionFunc: method is nil but Config.LabelVersion was just called")
	}
	callInfo := struct {
	}{}
	mock.lockLabelVersion.Lock()
	mock.calls.LabelVersion = append(mock.calls.LabelVersion, callInfo)
	mock.lockLabelVersion.Unlock()
	return mock.LabelVersionFunc()
}

// LabelVersionCalls gets all the calls that were made to LabelVersion.
// Check the length with:
//
//	len(mockedConfig.LabelVersionCalls())
func (mock *ConfigMock) LabelVersionCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockLabelVersion.RLock()
	calls = mock.calls.LabelVersion
	mock.lockLabelVersion.RUnlock()
	return calls
}

// LabelWorkdir calls LabelWorkdirFunc.
func (mock *ConfigMock) LabelWorkdir() string {
	if mock.LabelWorkdirFunc == nil {
		panic("ConfigMock.LabelWorkdirFunc: method is nil but Config.LabelWorkdir was just called")
	}
	callInfo := struct {
	}{}
	mock.lockLabelWorkdir.Lock()
	mock.calls.LabelWorkdir = append(mock.calls.LabelWorkdir, callInfo)
	mock.lockLabelWorkdir.Unlock()
	return mock.LabelWorkdirFunc()
}

// LabelWorkdirCalls gets all the calls that were made to LabelWorkdir.
// Check the length with:
//
//	len(mockedConfig.LabelWorkdirCalls())
func (mock *ConfigMock) LabelWorkdirCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockLabelWorkdir.RLock()
	calls = mock.calls.LabelWorkdir
	mock.lockLabelWorkdir.RUnlock()
	return calls
}

// LoggingConfig calls LoggingConfigFunc.
func (mock *ConfigMock) LoggingConfig() config.LoggingConfig {
	if mock.LoggingConfigFunc == nil {
		panic("ConfigMock.LoggingConfigFunc: method is nil but Config.LoggingConfig was just called")
	}
	callInfo := struct {
	}{}
	mock.lockLoggingConfig.Lock()
	mock.calls.LoggingConfig = append(mock.calls.LoggingConfig, callInfo)
	mock.lockLoggingConfig.Unlock()
	return mock.LoggingConfigFunc()
}

// LoggingConfigCalls gets all the calls that were made to LoggingConfig.
// Check the length with:
//
//	len(mockedConfig.LoggingConfigCalls())
func (mock *ConfigMock) LoggingConfigCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockLoggingConfig.RLock()
	calls = mock.calls.LoggingConfig
	mock.lockLoggingConfig.RUnlock()
	return calls
}

// LogsSubdir calls LogsSubdirFunc.
func (mock *ConfigMock) LogsSubdir() (string, error) {
	if mock.LogsSubdirFunc == nil {
		panic("ConfigMock.LogsSubdirFunc: method is nil but Config.LogsSubdir was just called")
	}
	callInfo := struct {
	}{}
	mock.lockLogsSubdir.Lock()
	mock.calls.LogsSubdir = append(mock.calls.LogsSubdir, callInfo)
	mock.lockLogsSubdir.Unlock()
	return mock.LogsSubdirFunc()
}

// LogsSubdirCalls gets all the calls that were made to LogsSubdir.
// Check the length with:
//
//	len(mockedConfig.LogsSubdirCalls())
func (mock *ConfigMock) LogsSubdirCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockLogsSubdir.RLock()
	calls = mock.calls.LogsSubdir
	mock.lockLogsSubdir.RUnlock()
	return calls
}

// ManagedLabelValue calls ManagedLabelValueFunc.
func (mock *ConfigMock) ManagedLabelValue() string {
	if mock.ManagedLabelValueFunc == nil {
		panic("ConfigMock.ManagedLabelValueFunc: method is nil but Config.ManagedLabelValue was just called")
	}
	callInfo := struct {
	}{}
	mock.lockManagedLabelValue.Lock()
	mock.calls.ManagedLabelValue = append(mock.calls.ManagedLabelValue, callInfo)
	mock.lockManagedLabelValue.Unlock()
	return mock.ManagedLabelValueFunc()
}

// ManagedLabelValueCalls gets all the calls that were made to ManagedLabelValue.
// Check the length with:
//
//	len(mockedConfig.ManagedLabelValueCalls())
func (mock *ConfigMock) ManagedLabelValueCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockManagedLabelValue.RLock()
	calls = mock.calls.ManagedLabelValue
	mock.lockManagedLabelValue.RUnlock()
	return calls
}

// MonitorSubdir calls MonitorSubdirFunc.
func (mock *ConfigMock) MonitorSubdir() (string, error) {
	if mock.MonitorSubdirFunc == nil {
		panic("ConfigMock.MonitorSubdirFunc: method is nil but Config.MonitorSubdir was just called")
	}
	callInfo := struct {
	}{}
	mock.lockMonitorSubdir.Lock()
	mock.calls.MonitorSubdir = append(mock.calls.MonitorSubdir, callInfo)
	mock.lockMonitorSubdir.Unlock()
	return mock.MonitorSubdirFunc()
}

// MonitorSubdirCalls gets all the calls that were made to MonitorSubdir.
// Check the length with:
//
//	len(mockedConfig.MonitorSubdirCalls())
func (mock *ConfigMock) MonitorSubdirCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockMonitorSubdir.RLock()
	calls = mock.calls.MonitorSubdir
	mock.lockMonitorSubdir.RUnlock()
	return calls
}

// MonitoringConfig calls MonitoringConfigFunc.
func (mock *ConfigMock) MonitoringConfig() config.MonitoringConfig {
	if mock.MonitoringConfigFunc == nil {
		panic("ConfigMock.MonitoringConfigFunc: method is nil but Config.MonitoringConfig was just called")
	}
	callInfo := struct {
	}{}
	mock.lockMonitoringConfig.Lock()
	mock.calls.MonitoringConfig = append(mock.calls.MonitoringConfig, callInfo)
	mock.lockMonitoringConfig.Unlock()
	return mock.MonitoringConfigFunc()
}

// MonitoringConfigCalls gets all the calls that were made to MonitoringConfig.
// Check the length with:
//
//	len(mockedConfig.MonitoringConfigCalls())
func (mock *ConfigMock) MonitoringConfigCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockMonitoringConfig.RLock()
	calls = mock.calls.MonitoringConfig
	mock.lockMonitoringConfig.RUnlock()
	return calls
}

// OpenSearchDashboardsURL calls OpenSearchDashboardsURLFunc.
func (mock *ConfigMock) OpenSearchDashboardsURL() string {
	if mock.OpenSearchDashboardsURLFunc == nil {
		panic("ConfigMock.OpenSearchDashboardsURLFunc: method is nil but Config.OpenSearchDashboardsURL was just called")
	}
	callInfo := struct {
	}{}
	mock.lockOpenSearchDashboardsURL.Lock()
	mock.calls.OpenSearchDashboardsURL = append(mock.calls.OpenSearchDashboardsURL, callInfo)
	mock.lockOpenSearchDashboardsURL.Unlock()
	return mock.OpenSearchDashboardsURLFunc()
}

// OpenSearchDashboardsURLCalls gets all the calls that were made to OpenSearchDashboardsURL.
// Check the length with:
//
//	len(mockedConfig.OpenSearchDashboardsURLCalls())
func (mock *ConfigMock) OpenSearchDashboardsURLCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockOpenSearchDashboardsURL.RLock()
	calls = mock.calls.OpenSearchDashboardsURL
	mock.lockOpenSearchDashboardsURL.RUnlock()
	return calls
}

// OpenSearchURL calls OpenSearchURLFunc.
func (mock *ConfigMock) OpenSearchURL() string {
	if mock.OpenSearchURLFunc == nil {
		panic("ConfigMock.OpenSearchURLFunc: method is nil but Config.OpenSearchURL was just called")
	}
	callInfo := struct {
	}{}
	mock.lockOpenSearchURL.Lock()
	mock.calls.OpenSearchURL = append(mock.calls.OpenSearchURL, callInfo)
	mock.lockOpenSearchURL.Unlock()
	return mock.OpenSearchURLFunc()
}

// OpenSearchURLCalls gets all the calls that were made to OpenSearchURL.
// Check the length with:
//
//	len(mockedConfig.OpenSearchURLCalls())
func (mock *ConfigMock) OpenSearchURLCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockOpenSearchURL.RLock()
	calls = mock.calls.OpenSearchURL
	mock.lockOpenSearchURL.RUnlock()
	return calls
}

// OtelCollectorURL calls OtelCollectorURLFunc.
func (mock *ConfigMock) OtelCollectorURL() string {
	if mock.OtelCollectorURLFunc == nil {
		panic("ConfigMock.OtelCollectorURLFunc: method is nil but Config.OtelCollectorURL was just called")
	}
	callInfo := struct {
	}{}
	mock.lockOtelCollectorURL.Lock()
	mock.calls.OtelCollectorURL = append(mock.calls.OtelCollectorURL, callInfo)
	mock.lockOtelCollectorURL.Unlock()
	return mock.OtelCollectorURLFunc()
}

// OtelCollectorURLCalls gets all the calls that were made to OtelCollectorURL.
// Check the length with:
//
//	len(mockedConfig.OtelCollectorURLCalls())
func (mock *ConfigMock) OtelCollectorURLCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockOtelCollectorURL.RLock()
	calls = mock.calls.OtelCollectorURL
	mock.lockOtelCollectorURL.RUnlock()
	return calls
}

// PidsSubdir calls PidsSubdirFunc.
func (mock *ConfigMock) PidsSubdir() (string, error) {
	if mock.PidsSubdirFunc == nil {
		panic("ConfigMock.PidsSubdirFunc: method is nil but Config.PidsSubdir was just called")
	}
	callInfo := struct {
	}{}
	mock.lockPidsSubdir.Lock()
	mock.calls.PidsSubdir = append(mock.calls.PidsSubdir, callInfo)
	mock.lockPidsSubdir.Unlock()
	return mock.PidsSubdirFunc()
}

// PidsSubdirCalls gets all the calls that were made to PidsSubdir.
// Check the length with:
//
//	len(mockedConfig.PidsSubdirCalls())
func (mock *ConfigMock) PidsSubdirCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockPidsSubdir.RLock()
	calls = mock.calls.PidsSubdir
	mock.lockPidsSubdir.RUnlock()
	return calls
}

// Project calls ProjectFunc.
func (mock *ConfigMock) Project() *config.Project {
	if mock.ProjectFunc == nil {
		panic("ConfigMock.ProjectFunc: method is nil but Config.Project was just called")
	}
	callInfo := struct {
	}{}
	mock.lockProject.Lock()
	mock.calls.Project = append(mock.calls.Project, callInfo)
	mock.lockProject.Unlock()
	return mock.ProjectFunc()
}

// ProjectCalls gets all the calls that were made to Project.
// Check the length with:
//
//	len(mockedConfig.ProjectCalls())
func (mock *ConfigMock) ProjectCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockProject.RLock()
	calls = mock.calls.Project
	mock.lockProject.RUnlock()
	return calls
}

// ProjectConfigFileName calls ProjectConfigFileNameFunc.
func (mock *ConfigMock) ProjectConfigFileName() string {
	if mock.ProjectConfigFileNameFunc == nil {
		panic("ConfigMock.ProjectConfigFileNameFunc: method is nil but Config.ProjectConfigFileName was just called")
	}
	callInfo := struct {
	}{}
	mock.lockProjectConfigFileName.Lock()
	mock.calls.ProjectConfigFileName = append(mock.calls.ProjectConfigFileName, callInfo)
	mock.lockProjectConfigFileName.Unlock()
	return mock.ProjectConfigFileNameFunc()
}

// ProjectConfigFileNameCalls gets all the calls that were made to ProjectConfigFileName.
// Check the length with:
//
//	len(mockedConfig.ProjectConfigFileNameCalls())
func (mock *ConfigMock) ProjectConfigFileNameCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockProjectConfigFileName.RLock()
	calls = mock.calls.ProjectConfigFileName
	mock.lockProjectConfigFileName.RUnlock()
	return calls
}

// ProjectRegistryFileName calls ProjectRegistryFileNameFunc.
func (mock *ConfigMock) ProjectRegistryFileName() string {
	if mock.ProjectRegistryFileNameFunc == nil {
		panic("ConfigMock.ProjectRegistryFileNameFunc: method is nil but Config.ProjectRegistryFileName was just called")
	}
	callInfo := struct {
	}{}
	mock.lockProjectRegistryFileName.Lock()
	mock.calls.ProjectRegistryFileName = append(mock.calls.ProjectRegistryFileName, callInfo)
	mock.lockProjectRegistryFileName.Unlock()
	return mock.ProjectRegistryFileNameFunc()
}

// ProjectRegistryFileNameCalls gets all the calls that were made to ProjectRegistryFileName.
// Check the length with:
//
//	len(mockedConfig.ProjectRegistryFileNameCalls())
func (mock *ConfigMock) ProjectRegistryFileNameCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockProjectRegistryFileName.RLock()
	calls = mock.calls.ProjectRegistryFileName
	mock.lockProjectRegistryFileName.RUnlock()
	return calls
}

// ProjectStore calls ProjectStoreFunc.
func (mock *ConfigMock) ProjectStore() *storage.Store[config.Project] {
	if mock.ProjectStoreFunc == nil {
		panic("ConfigMock.ProjectStoreFunc: method is nil but Config.ProjectStore was just called")
	}
	callInfo := struct {
	}{}
	mock.lockProjectStore.Lock()
	mock.calls.ProjectStore = append(mock.calls.ProjectStore, callInfo)
	mock.lockProjectStore.Unlock()
	return mock.ProjectStoreFunc()
}

// ProjectStoreCalls gets all the calls that were made to ProjectStore.
// Check the length with:
//
//	len(mockedConfig.ProjectStoreCalls())
func (mock *ConfigMock) ProjectStoreCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockProjectStore.RLock()
	calls = mock.calls.ProjectStore
	mock.lockProjectStore.RUnlock()
	return calls
}

// PrometheusURL calls PrometheusURLFunc.
func (mock *ConfigMock) PrometheusURL() string {
	if mock.PrometheusURLFunc == nil {
		panic("ConfigMock.PrometheusURLFunc: method is nil but Config.PrometheusURL was just called")
	}
	callInfo := struct {
	}{}
	mock.lockPrometheusURL.Lock()
	mock.calls.PrometheusURL = append(mock.calls.PrometheusURL, callInfo)
	mock.lockPrometheusURL.Unlock()
	return mock.PrometheusURLFunc()
}

// PrometheusURLCalls gets all the calls that were made to PrometheusURL.
// Check the length with:
//
//	len(mockedConfig.PrometheusURLCalls())
func (mock *ConfigMock) PrometheusURLCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockPrometheusURL.RLock()
	calls = mock.calls.PrometheusURL
	mock.lockPrometheusURL.RUnlock()
	return calls
}

// PurposeAgent calls PurposeAgentFunc.
func (mock *ConfigMock) PurposeAgent() string {
	if mock.PurposeAgentFunc == nil {
		panic("ConfigMock.PurposeAgentFunc: method is nil but Config.PurposeAgent was just called")
	}
	callInfo := struct {
	}{}
	mock.lockPurposeAgent.Lock()
	mock.calls.PurposeAgent = append(mock.calls.PurposeAgent, callInfo)
	mock.lockPurposeAgent.Unlock()
	return mock.PurposeAgentFunc()
}

// PurposeAgentCalls gets all the calls that were made to PurposeAgent.
// Check the length with:
//
//	len(mockedConfig.PurposeAgentCalls())
func (mock *ConfigMock) PurposeAgentCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockPurposeAgent.RLock()
	calls = mock.calls.PurposeAgent
	mock.lockPurposeAgent.RUnlock()
	return calls
}

// PurposeFirewall calls PurposeFirewallFunc.
func (mock *ConfigMock) PurposeFirewall() string {
	if mock.PurposeFirewallFunc == nil {
		panic("ConfigMock.PurposeFirewallFunc: method is nil but Config.PurposeFirewall was just called")
	}
	callInfo := struct {
	}{}
	mock.lockPurposeFirewall.Lock()
	mock.calls.PurposeFirewall = append(mock.calls.PurposeFirewall, callInfo)
	mock.lockPurposeFirewall.Unlock()
	return mock.PurposeFirewallFunc()
}

// PurposeFirewallCalls gets all the calls that were made to PurposeFirewall.
// Check the length with:
//
//	len(mockedConfig.PurposeFirewallCalls())
func (mock *ConfigMock) PurposeFirewallCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockPurposeFirewall.RLock()
	calls = mock.calls.PurposeFirewall
	mock.lockPurposeFirewall.RUnlock()
	return calls
}

// PurposeMonitoring calls PurposeMonitoringFunc.
func (mock *ConfigMock) PurposeMonitoring() string {
	if mock.PurposeMonitoringFunc == nil {
		panic("ConfigMock.PurposeMonitoringFunc: method is nil but Config.PurposeMonitoring was just called")
	}
	callInfo := struct {
	}{}
	mock.lockPurposeMonitoring.Lock()
	mock.calls.PurposeMonitoring = append(mock.calls.PurposeMonitoring, callInfo)
	mock.lockPurposeMonitoring.Unlock()
	return mock.PurposeMonitoringFunc()
}

// PurposeMonitoringCalls gets all the calls that were made to PurposeMonitoring.
// Check the length with:
//
//	len(mockedConfig.PurposeMonitoringCalls())
func (mock *ConfigMock) PurposeMonitoringCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockPurposeMonitoring.RLock()
	calls = mock.calls.PurposeMonitoring
	mock.lockPurposeMonitoring.RUnlock()
	return calls
}

// RequiredFirewallDomains calls RequiredFirewallDomainsFunc.
func (mock *ConfigMock) RequiredFirewallDomains() []string {
	if mock.RequiredFirewallDomainsFunc == nil {
		panic("ConfigMock.RequiredFirewallDomainsFunc: method is nil but Config.RequiredFirewallDomains was just called")
	}
	callInfo := struct {
	}{}
	mock.lockRequiredFirewallDomains.Lock()
	mock.calls.RequiredFirewallDomains = append(mock.calls.RequiredFirewallDomains, callInfo)
	mock.lockRequiredFirewallDomains.Unlock()
	return mock.RequiredFirewallDomainsFunc()
}

// RequiredFirewallDomainsCalls gets all the calls that were made to RequiredFirewallDomains.
// Check the length with:
//
//	len(mockedConfig.RequiredFirewallDomainsCalls())
func (mock *ConfigMock) RequiredFirewallDomainsCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockRequiredFirewallDomains.RLock()
	calls = mock.calls.RequiredFirewallDomains
	mock.lockRequiredFirewallDomains.RUnlock()
	return calls
}

// RequiredFirewallRules calls RequiredFirewallRulesFunc.
func (mock *ConfigMock) RequiredFirewallRules() []config.EgressRule {
	if mock.RequiredFirewallRulesFunc == nil {
		panic("ConfigMock.RequiredFirewallRulesFunc: method is nil but Config.RequiredFirewallRules was just called")
	}
	callInfo := struct {
	}{}
	mock.lockRequiredFirewallRules.Lock()
	mock.calls.RequiredFirewallRules = append(mock.calls.RequiredFirewallRules, callInfo)
	mock.lockRequiredFirewallRules.Unlock()
	return mock.RequiredFirewallRulesFunc()
}

// RequiredFirewallRulesCalls gets all the calls that were made to RequiredFirewallRules.
// Check the length with:
//
//	len(mockedConfig.RequiredFirewallRulesCalls())
func (mock *ConfigMock) RequiredFirewallRulesCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockRequiredFirewallRules.RLock()
	calls = mock.calls.RequiredFirewallRules
	mock.lockRequiredFirewallRules.RUnlock()
	return calls
}

// Settings calls SettingsFunc.
func (mock *ConfigMock) Settings() *config.Settings {
	if mock.SettingsFunc == nil {
		panic("ConfigMock.SettingsFunc: method is nil but Config.Settings was just called")
	}
	callInfo := struct {
	}{}
	mock.lockSettings.Lock()
	mock.calls.Settings = append(mock.calls.Settings, callInfo)
	mock.lockSettings.Unlock()
	return mock.SettingsFunc()
}

// SettingsCalls gets all the calls that were made to Settings.
// Check the length with:
//
//	len(mockedConfig.SettingsCalls())
func (mock *ConfigMock) SettingsCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockSettings.RLock()
	calls = mock.calls.Settings
	mock.lockSettings.RUnlock()
	return calls
}

// SettingsFileName calls SettingsFileNameFunc.
func (mock *ConfigMock) SettingsFileName() string {
	if mock.SettingsFileNameFunc == nil {
		panic("ConfigMock.SettingsFileNameFunc: method is nil but Config.SettingsFileName was just called")
	}
	callInfo := struct {
	}{}
	mock.lockSettingsFileName.Lock()
	mock.calls.SettingsFileName = append(mock.calls.SettingsFileName, callInfo)
	mock.lockSettingsFileName.Unlock()
	return mock.SettingsFileNameFunc()
}

// SettingsFileNameCalls gets all the calls that were made to SettingsFileName.
// Check the length with:
//
//	len(mockedConfig.SettingsFileNameCalls())
func (mock *ConfigMock) SettingsFileNameCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockSettingsFileName.RLock()
	calls = mock.calls.SettingsFileName
	mock.lockSettingsFileName.RUnlock()
	return calls
}

// SettingsStore calls SettingsStoreFunc.
func (mock *ConfigMock) SettingsStore() *storage.Store[config.Settings] {
	if mock.SettingsStoreFunc == nil {
		panic("ConfigMock.SettingsStoreFunc: method is nil but Config.SettingsStore was just called")
	}
	callInfo := struct {
	}{}
	mock.lockSettingsStore.Lock()
	mock.calls.SettingsStore = append(mock.calls.SettingsStore, callInfo)
	mock.lockSettingsStore.Unlock()
	return mock.SettingsStoreFunc()
}

// SettingsStoreCalls gets all the calls that were made to SettingsStore.
// Check the length with:
//
//	len(mockedConfig.SettingsStoreCalls())
func (mock *ConfigMock) SettingsStoreCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockSettingsStore.RLock()
	calls = mock.calls.SettingsStore
	mock.lockSettingsStore.RUnlock()
	return calls
}

// ShareSubdir calls ShareSubdirFunc.
func (mock *ConfigMock) ShareSubdir() (string, error) {
	if mock.ShareSubdirFunc == nil {
		panic("ConfigMock.ShareSubdirFunc: method is nil but Config.ShareSubdir was just called")
	}
	callInfo := struct {
	}{}
	mock.lockShareSubdir.Lock()
	mock.calls.ShareSubdir = append(mock.calls.ShareSubdir, callInfo)
	mock.lockShareSubdir.Unlock()
	return mock.ShareSubdirFunc()
}

// ShareSubdirCalls gets all the calls that were made to ShareSubdir.
// Check the length with:
//
//	len(mockedConfig.ShareSubdirCalls())
func (mock *ConfigMock) ShareSubdirCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockShareSubdir.RLock()
	calls = mock.calls.ShareSubdir
	mock.lockShareSubdir.RUnlock()
	return calls
}

// StateDirEnvVar calls StateDirEnvVarFunc.
func (mock *ConfigMock) StateDirEnvVar() string {
	if mock.StateDirEnvVarFunc == nil {
		panic("ConfigMock.StateDirEnvVarFunc: method is nil but Config.StateDirEnvVar was just called")
	}
	callInfo := struct {
	}{}
	mock.lockStateDirEnvVar.Lock()
	mock.calls.StateDirEnvVar = append(mock.calls.StateDirEnvVar, callInfo)
	mock.lockStateDirEnvVar.Unlock()
	return mock.StateDirEnvVarFunc()
}

// StateDirEnvVarCalls gets all the calls that were made to StateDirEnvVar.
// Check the length with:
//
//	len(mockedConfig.StateDirEnvVarCalls())
func (mock *ConfigMock) StateDirEnvVarCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockStateDirEnvVar.RLock()
	calls = mock.calls.StateDirEnvVar
	mock.lockStateDirEnvVar.RUnlock()
	return calls
}

// TestRepoDirEnvVar calls TestRepoDirEnvVarFunc.
func (mock *ConfigMock) TestRepoDirEnvVar() string {
	if mock.TestRepoDirEnvVarFunc == nil {
		panic("ConfigMock.TestRepoDirEnvVarFunc: method is nil but Config.TestRepoDirEnvVar was just called")
	}
	callInfo := struct {
	}{}
	mock.lockTestRepoDirEnvVar.Lock()
	mock.calls.TestRepoDirEnvVar = append(mock.calls.TestRepoDirEnvVar, callInfo)
	mock.lockTestRepoDirEnvVar.Unlock()
	return mock.TestRepoDirEnvVarFunc()
}

// TestRepoDirEnvVarCalls gets all the calls that were made to TestRepoDirEnvVar.
// Check the length with:
//
//	len(mockedConfig.TestRepoDirEnvVarCalls())
func (mock *ConfigMock) TestRepoDirEnvVarCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockTestRepoDirEnvVar.RLock()
	calls = mock.calls.TestRepoDirEnvVar
	mock.lockTestRepoDirEnvVar.RUnlock()
	return calls
}

// WorktreesSubdir calls WorktreesSubdirFunc.
func (mock *ConfigMock) WorktreesSubdir() (string, error) {
	if mock.WorktreesSubdirFunc == nil {
		panic("ConfigMock.WorktreesSubdirFunc: method is nil but Config.WorktreesSubdir was just called")
	}
	callInfo := struct {
	}{}
	mock.lockWorktreesSubdir.Lock()
	mock.calls.WorktreesSubdir = append(mock.calls.WorktreesSubdir, callInfo)
	mock.lockWorktreesSubdir.Unlock()
	return mock.WorktreesSubdirFunc()
}

// WorktreesSubdirCalls gets all the calls that were made to WorktreesSubdir.
// Check the length with:
//
//	len(mockedConfig.WorktreesSubdirCalls())
func (mock *ConfigMock) WorktreesSubdirCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockWorktreesSubdir.RLock()
	calls = mock.calls.WorktreesSubdir
	mock.lockWorktreesSubdir.RUnlock()
	return calls
}
