pro

var AddRemoteNodePortSANs = func(_ context.Context, _, _ string, _ kubernetes.Interface) error {
	return nil
}

var ApplyIstioPatches = func(_ *synccontext.SyncContext, _, _, _ client.Object) error {
	return nil
}

var ApplyPatchesHostObject = func(_ *synccontext.SyncContext, _, _, _ client.Object, patches []config.TranslatePatch, _ bool) error {
	if len(patches) == 0 {
		return nil
	}

	return NewFeatureError("translate patches")
}

var ApplyPatchesVirtualObject = func(_ *synccontext.SyncContext, _, _, _ client.Object, patches []config.TranslatePatch, _ bool) error {
	if len(patches) == 0 {
		return nil
	}

	return NewFeatureError("translate patches")
}

var BuildProSyncers = func(_ *synccontext.RegisterContext) ([]syncertypes.Object, error) {
	return []syncertypes.Object{}, nil
}

var ConfigureExternalDatabase = func(_ context.Context, _ string, _ *config.VirtualClusterConfig, _ bool) (string, *etcd.Certificates, error) {
	return "", nil, NewFeatureError("external database")
}

var ExchangeControlPlaneClient = func(controllerCtx *synccontext.ControllerContext) (client.Client, error) {
	return controllerCtx.WorkloadNamespaceClient, nil
}

var GetNamespaceMapper = func(_ *synccontext.RegisterContext, _ synccontext.Mapper) (synccontext.Mapper, error) {
	return nil, NewFeatureError("namespace toHost syncing")
}

var GetRemoteClient = func(vConfig *config.VirtualClusterConfig) (*rest.Config, string, string, *rest.Config, string, string, error) {
	inClusterConfig := ctrl.GetConfigOrDie()
	inClusterConfig.QPS = 40
	inClusterConfig.Burst = 80
	inClusterConfig.Timeout = 0

	currentNamespace, err := clienthelper.CurrentNamespace()
	if err != nil {
		return nil, "", "", nil, "", "", err
	}

	if vConfig.Experimental.IsolatedControlPlane.Enabled {
		return nil, "", "", nil, "", "", NewFeatureError(string(licenseapi.VirtualClusterProDistroIsolatedControlPlane))
	}

	return inClusterConfig, currentNamespace, vConfig.ControlPlaneService, inClusterConfig, currentNamespace, vConfig.ControlPlaneService, nil
}

var GetWithSyncedNamespacesTranslator = func(_ string, _ config.FromHostMappings) (translate.Translator, error) {
	return nil, NewFeatureError("namespace toHost syncing")
}

var InitDNSServiceSyncing = func(_ *config.VirtualClusterConfig) specialservices.Interface {
	return specialservices.NewDefaultServiceSyncer()
}

var InitProControllerContext = func(_ *synccontext.ControllerContext) error {
	return nil
}

var LicenseFeatures = func() map[string]bool {
	return make(map[string]bool)
}

var LicenseInit = func(_ context.Context, _ *config.VirtualClusterConfig) error {
	return nil
}

var LicenseStart = func(_ *synccontext.ControllerContext) error {
	return nil
}

var NewImporter = func(_ synccontext.Mapper) syncertypes.Importer {
	return &noopImporter{}
}

var NewPhysicalClient = func(_ *config.VirtualClusterConfig) client.NewClientFunc {
	return pluginhookclient.NewPhysicalPluginClientFactory(blockingcacheclient.NewCacheClient)
}

var NewVirtualClient = func(_ *config.VirtualClusterConfig) client.NewClientFunc {
	return pluginhookclient.NewVirtualPluginClientFactory(blockingcacheclient.NewCacheClient)
}

var RegisterProControllers = func(*synccontext.ControllerContext) error {
	return nil
}

var StartEmbeddedEtcd = func(_ context.Context, _, _ string, _ kubernetes.Interface, _ string, _ int, _ string, _ bool, _ []string, _ bool) error {
	return NewFeatureError("embedded etcd")
}

var StartIntegratedCoreDNS = func(_ *synccontext.ControllerContext) error {
	return NewFeatureError("integrated core dns")
}

var StartKonnectivity = func(_ context.Context, vConfig *config.VirtualClusterConfig) error {

	if !vConfig.PrivateNodes.Enabled {
		return nil
	}

	return NewFeatureError("private nodes")
}

var StartPrivateNodesMode = func(ctx *synccontext.ControllerContext) error {

	if !ctx.Config.PrivateNodes.Enabled {
		return nil
	}

	return NewFeatureError("private nodes")
}

var StartStandalone = func(_ context.Context, _ *StandaloneOptions) error {
	return NewFeatureError("private nodes standalone")
}

var SyncKubernetesServiceDedicated = func(ctx *synccontext.SyncContext) error {

	if !ctx.Config.PrivateNodes.Enabled {
		return nil
	}

	return NewFeatureError("private nodes")
}

var SyncRemoteEndpoints = func(_ context.Context, _ types.NamespacedName, _ client.Client, _ types.NamespacedName, _ client.Client) error {
	return NewFeatureError(string(licenseapi.VirtualClusterProDistroIsolatedControlPlane))
}

var UpgradeNode = func(_ context.Context, _ *UpgradeOptions) error {
	return NewFeatureError("private nodes")
}

var WriteKonnectivityEgressConfig = func() (string, error) {
	return "", NewFeatureError("private nodes")
}